Added the test that needed a VirtualTimer (#1488)

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/VirtualTimer.java

@@ -0,0 +1,152 @@
+package org.yakindu.scr;
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+import org.yakindu.scr.ITimer;
+import org.yakindu.scr.ITimerCallback;
+
+public class VirtualTimer implements ITimer {
+
+	private long virtualTime = 0;
+
+	private Queue<VirtualTimeTask> tasks;
+
+	public abstract static class VirtualTimeTask implements Runnable, Comparable<VirtualTimeTask> {
+
+		long nextExecutionTime = 0;
+		long interval = 0;
+		long period = -1;
+		boolean isCanceled = false;
+
+		public int compareTo(VirtualTimeTask o) {
+			return (int) (nextExecutionTime - o.nextExecutionTime);
+		}
+
+		public boolean isCanceled() {
+			return isCanceled;
+		}
+
+		public void cancel() {
+			isCanceled = true;
+		}
+	}
+
+	public static class VirtualTimeEventTask extends VirtualTimeTask {
+
+		private final int eventID;
+		private ITimerCallback callback;
+
+		public VirtualTimeEventTask(ITimerCallback callback, int eventID) {
+			this.callback = callback;
+			this.eventID = eventID;
+		}
+
+		public int getEventId() {
+			return eventID;
+		}
+
+		public void run() {
+			callback.timeElapsed(eventID);
+		}
+
+	}
+
+	public VirtualTimer() {
+		tasks = new PriorityQueue<VirtualTimeTask>();
+	}
+
+	public void timeLeap(long ms) {
+		virtualTime += ms;
+		processTasks();
+	}
+
+	@Override
+	public void setTimer(ITimerCallback callback, int eventID, long duration, boolean isPeriodical) {
+		if (duration <= 0)
+			duration = 1;
+		VirtualTimeEventTask timeEventTask = new VirtualTimeEventTask(callback, eventID);
+		if (isPeriodical) {
+			schedulePeriodicalTask(timeEventTask, duration, duration);
+		} else {
+			scheduleTask(timeEventTask, duration);
+		}
+	}
+
+	@Override
+	public void unsetTimer(ITimerCallback callback, int eventID) {
+		VirtualTimeTask timerTask = getTask(eventID);
+		if (timerTask != null)
+			timerTask.cancel();
+	}
+
+	public void scheduleTask(VirtualTimeTask task, long interval) {
+		task.interval = interval;
+		scheduleInternal(task, virtualTime + interval, -1);
+	}
+
+	public void schedulePeriodicalTask(VirtualTimeTask task, long interval, long period) {
+		task.interval = interval;
+		scheduleInternal(task, virtualTime + interval, period);
+	}
+
+	private void scheduleInternal(VirtualTimeTask task, long time, long period) {
+		task.nextExecutionTime = time;
+		task.period = period;
+		tasks.add(task);
+	}
+
+	protected VirtualTimeTask getTask(int eventName) {
+		for (VirtualTimeTask virtualTimeTask : tasks) {
+			if (!(virtualTimeTask instanceof VirtualTimeEventTask))
+				continue;
+			if (((VirtualTimeEventTask) virtualTimeTask).getEventId() == eventName)
+				return virtualTimeTask;
+		}
+		return null;
+	}
+
+	protected void processTasks() {
+		boolean processTasks = !tasks.isEmpty();
+		while (processTasks) {
+			VirtualTimeTask task = tasks.peek();
+			if (task == null)
+				break;
+			if (task.isCanceled) {
+				tasks.remove();
+				continue;
+			}
+			long executionTime = task.nextExecutionTime;
+			if (executionTime <= virtualTime) {
+				task = tasks.poll();
+				task.run();
+				if (task.period > -1) {
+					schedulePeriodicalTask(task, task.interval, task.period);
+				}
+			} else {
+				processTasks = false;
+			}
+		}
+	}
+
+	public synchronized void pause() {
+		throw new RuntimeException("Implement me");
+	}
+
+	public synchronized void resume() {
+		throw new RuntimeException("Implement me");
+	}
+
+	public synchronized void stop() {
+		for (VirtualTimeTask timerTask : tasks) {
+			timerTask.cancel();
+		}
+		cancel();
+	}
+
+	public void cancel() {
+		synchronized (tasks) {
+			tasks.clear();
+		}
+	}
+
+}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/AllTests.java

@@ -76,7 +76,9 @@ import org.junit.runners.Suite.SuiteClasses;
 	TriggerGuardExpressions.class,
 	TriggerExpressionPrecedence.class,
 	ValuedEvents.class,
-	TypeAlias.class
+	TypeAlias.class,
+	StatemachineKeywords.class,
+	TimedTransitions.class
 	})
 public class AllTests {
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/AlwaysOncycle.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.alwaysoncycle.AlwaysOncycleStatemachine;
-import org.yakindu.scr.alwaysoncycle.AlwaysOncycleStatemachine.State;
+import org.yakindu.scr.alwaysoncycle.AlwaysOncycleStatemachine.State;	
 
 /**
  * Unit TestCase for AlwaysOncycle
  */
 @SuppressWarnings("all")
 public class AlwaysOncycle {
+	
 	private AlwaysOncycleStatemachine statemachine;	
 	
 	@Before
@@ -36,19 +37,19 @@ public class AlwaysOncycle {
 	
 	@Test
 	public void alwaysOnCycleTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_StateA));
 		while (statemachine.getValue() < 5l) {
-			statemachine.runCycle();;
+			statemachine.runCycle();
 			assertTrue(statemachine.isStateActive(State.main_region_StateA));
 		}
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_StateB));
 		while (statemachine.getValue() < 5l) {
-			statemachine.runCycle();;
+			statemachine.runCycle();
 			assertTrue(statemachine.isStateActive(State.main_region_StateB));
 		}
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_StateA));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/AssignmentAsExpression.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.assignmentasexpression.AssignmentAsExpressionStatemachine;
-import org.yakindu.scr.assignmentasexpression.AssignmentAsExpressionStatemachine.State;
+import org.yakindu.scr.assignmentasexpression.AssignmentAsExpressionStatemachine.State;	
 
 /**
  * Unit TestCase for AssignmentAsExpression
  */
 @SuppressWarnings("all")
 public class AssignmentAsExpression {
+	
 	private AssignmentAsExpressionStatemachine statemachine;	
 	
 	@Before
@@ -36,35 +37,35 @@ public class AssignmentAsExpression {
 	
 	@Test
 	public void simpleAssignment() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_Add));
 		assertTrue(statemachine.getB() == 5l);
 		assertTrue(statemachine.getA() == 9l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Subtract));
 		assertTrue(statemachine.getD() == 6l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Multiply));
 		assertTrue(statemachine.getE() == 15l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Divide));
 		assertTrue(statemachine.getG() == 1l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Modulo));
 		assertTrue(statemachine.getI() == 1l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Shift));
 		assertTrue(statemachine.getJ() == 16l);
 		assertTrue(statemachine.getK() == 4l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_boolean_And));
 		assertTrue(statemachine.getL() == 1l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_boolean_Or));
 		assertTrue(statemachine.getP() == 15l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_boolean_Xor));
 		assertTrue(statemachine.getU() == 12l);
-		statemachine.exit();;
+		statemachine.exit();
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/BitExpressions.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.bitexpressions.BitExpressionsStatemachine;
-import org.yakindu.scr.bitexpressions.BitExpressionsStatemachine.State;
+import org.yakindu.scr.bitexpressions.BitExpressionsStatemachine.State;	
 
 /**
  * Unit TestCase for BitExpressions
  */
 @SuppressWarnings("all")
 public class BitExpressions {
+	
 	private BitExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -36,12 +37,12 @@ public class BitExpressions {
 	
 	@Test
 	public void bitExpressions() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_StateA));
 		assertTrue(statemachine.getMyBit1() == 5l);
 		assertTrue(statemachine.getMyBit2() == 7l);
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_StateB));
 		assertTrue(statemachine.getLeftBitshift() == 10l);
 		assertTrue(statemachine.getRightBitshift() == 2l);

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/BooleanExpressions.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.booleanexpressions.BooleanExpressionsStatemachine;
-import org.yakindu.scr.booleanexpressions.BooleanExpressionsStatemachine.State;
+import org.yakindu.scr.booleanexpressions.BooleanExpressionsStatemachine.State;	
 
 /**
  * Unit TestCase for BooleanExpressions
  */
 @SuppressWarnings("all")
 public class BooleanExpressions {
+	
 	private BooleanExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -36,12 +37,12 @@ public class BooleanExpressions {
 	
 	@Test
 	public void booleanExpressions() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_StateA));
 		assertTrue(statemachine.getMyBool1() == true);
 		assertTrue(statemachine.getMyBool2() == false);
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_StateB));
 		assertTrue(statemachine.getAnd() == false);
 		assertTrue(statemachine.getOr() == true);

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/CKeywords.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.ckeywords.CKeywordsStatemachine;
-import org.yakindu.scr.ckeywords.CKeywordsStatemachine.State;
+import org.yakindu.scr.ckeywords.CKeywordsStatemachine.State;	
 
 /**
  * Unit TestCase for CKeywords
  */
 @SuppressWarnings("all")
 public class CKeywords {
+	
 	private CKeywordsStatemachine statemachine;	
 	
 	@Before
@@ -36,10 +37,10 @@ public class CKeywords {
 	
 	@Test
 	public void cKeywordsTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.auto_char));
 		statemachine.raiseAuto();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.auto_loop));
 		assertTrue(statemachine.isStateActive(State.auto_loop_switch_case));
 		assertTrue(statemachine.isStateActive(State.auto_loop_switch_case_enum_asm));

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/CastExpressions.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.castexpressions.CastExpressionsStatemachine;
-import org.yakindu.scr.castexpressions.CastExpressionsStatemachine.State;
+import org.yakindu.scr.castexpressions.CastExpressionsStatemachine.State;	
 
 /**
  * Unit TestCase for CastExpressions
  */
 @SuppressWarnings("all")
 public class CastExpressions {
+	
 	private CastExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -36,12 +37,12 @@ public class CastExpressions {
 	
 	@Test
 	public void castExpressionTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.getRealValue() == 5l);
 		assertTrue(statemachine.getIntValue() == 5l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getRealValue() == 15l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_C));
 		assertTrue(statemachine.getRealValue() == 757l);
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/Choice.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.choice.ChoiceStatemachine;
-import org.yakindu.scr.choice.ChoiceStatemachine.State;
+import org.yakindu.scr.choice.ChoiceStatemachine.State;	
 
 /**
  * Unit TestCase for Choice
  */
 @SuppressWarnings("all")
 public class Choice {
+	
 	private ChoiceStatemachine statemachine;	
 	
 	@Before
@@ -70,31 +71,31 @@ public class Choice {
 		assertTrue(statemachine.isStateActive(State.main_region_C));
 	}
 	public void initForEventE(boolean valueForC) {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.setC(valueForC);
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 	}
 	public void initForEventF(boolean valueForC) {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.setC(valueForC);
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 	}
 	public void initForEventG(boolean valueForC) {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.setC(valueForC);
 		statemachine.raiseG();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 	}
 	public void initForEventH(boolean valueForC) {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.setC(valueForC);
 		statemachine.raiseH();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ConditionalExpression.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.conditionalexpressions.ConditionalExpressionsStatemachine;
-import org.yakindu.scr.conditionalexpressions.ConditionalExpressionsStatemachine.State;
+import org.yakindu.scr.conditionalexpressions.ConditionalExpressionsStatemachine.State;	
 
 /**
  * Unit TestCase for ConditionalExpressions
  */
 @SuppressWarnings("all")
 public class ConditionalExpression {
+	
 	private ConditionalExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -36,11 +37,11 @@ public class ConditionalExpression {
 	
 	@Test
 	public void conditionalExpressionTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		assertTrue(statemachine.getCondition() == 1l);
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		assertTrue(statemachine.getCondition() == 2l);
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ConstOnlyDefaultScope.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.constonlydefaultscope.ConstOnlyDefaultScopeStatemachine;
-import org.yakindu.scr.constonlydefaultscope.ConstOnlyDefaultScopeStatemachine.State;
+import org.yakindu.scr.constonlydefaultscope.ConstOnlyDefaultScopeStatemachine.State;	
 
 /**
  * Unit TestCase for ConstOnlyDefaultScope
  */
 @SuppressWarnings("all")
 public class ConstOnlyDefaultScope {
+	
 	private ConstOnlyDefaultScopeStatemachine statemachine;	
 	
 	@Before
@@ -36,14 +37,14 @@ public class ConstOnlyDefaultScope {
 	
 	@Test
 	public void statechartEntry() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.constOnlyDefaultScope_main_region_A));
 	}
 	@Test
 	public void stateTransition() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.getSCIA().raiseE(1l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.constOnlyDefaultScope_main_region_B));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ConstOnlyInternalScope.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.constonlyinternalscope.ConstOnlyInternalScopeStatemachine;
-import org.yakindu.scr.constonlyinternalscope.ConstOnlyInternalScopeStatemachine.State;
+import org.yakindu.scr.constonlyinternalscope.ConstOnlyInternalScopeStatemachine.State;	
 
 /**
  * Unit TestCase for ConstOnlyInternalScope
  */
 @SuppressWarnings("all")
 public class ConstOnlyInternalScope {
+	
 	private ConstOnlyInternalScopeStatemachine statemachine;	
 	
 	@Before
@@ -36,14 +37,14 @@ public class ConstOnlyInternalScope {
 	
 	@Test
 	public void statechartEntry() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.constOnlyInternalScope_main_region_A));
 	}
 	@Test
 	public void stateTransition() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.raiseE(1l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.constOnlyInternalScope_main_region_B));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ConstOnlyNamedScope.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.constonlynamedscope.ConstOnlyNamedScopeStatemachine;
-import org.yakindu.scr.constonlynamedscope.ConstOnlyNamedScopeStatemachine.State;
+import org.yakindu.scr.constonlynamedscope.ConstOnlyNamedScopeStatemachine.State;	
 
 /**
  * Unit TestCase for ConstOnlyNamedScope
  */
 @SuppressWarnings("all")
 public class ConstOnlyNamedScope {
+	
 	private ConstOnlyNamedScopeStatemachine statemachine;	
 	
 	@Before
@@ -36,14 +37,14 @@ public class ConstOnlyNamedScope {
 	
 	@Test
 	public void statechartEntry() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.constOnlyNamedScope_main_region_A));
 	}
 	@Test
 	public void stateTransition() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.raiseE(1l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.constOnlyNamedScope_main_region_B));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ConstantsTests.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.constants.ConstantsStatemachine;
-import org.yakindu.scr.constants.ConstantsStatemachine.State;
+import org.yakindu.scr.constants.ConstantsStatemachine.State;	
 
 /**
  * Unit TestCase for Constants
  */
 @SuppressWarnings("all")
 public class ConstantsTests {
+	
 	private ConstantsStatemachine statemachine;	
 	
 	@Before
@@ -36,20 +37,20 @@ public class ConstantsTests {
 	
 	@Test
 	public void constantDefinition() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		assertTrue(statemachine.getX() == 10l);
 		assertTrue(statemachine.getY() == 20l);
 		assertTrue(statemachine.getSCINamed().getY().equals("Hello World"));
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getResult() == 20l);
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_C));
 		assertTrue(statemachine.getResult() == 100l);
 		statemachine.raiseE2(statemachine.getX());
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getResult() == 1000l);
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/Declarations.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.declarations.DeclarationsStatemachine;
-import org.yakindu.scr.declarations.DeclarationsStatemachine.State;
+import org.yakindu.scr.declarations.DeclarationsStatemachine.State;	
 
 /**
  * Unit TestCase for Declarations
  */
 @SuppressWarnings("all")
 public class Declarations {
+	
 	private DeclarationsStatemachine statemachine;	
 	
 	@Before
@@ -36,6 +37,6 @@ public class Declarations {
 	
 	@Test
 	public void declarationsTest() {
-		statemachine.enter();;
+		statemachine.enter();
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/DeepEntry.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.deepentry.DeepEntryStatemachine;
-import org.yakindu.scr.deepentry.DeepEntryStatemachine.State;
+import org.yakindu.scr.deepentry.DeepEntryStatemachine.State;	
 
 /**
  * Unit TestCase for DeepEntry
  */
 @SuppressWarnings("all")
 public class DeepEntry {
+	
 	private DeepEntryStatemachine statemachine;	
 	
 	@Before
@@ -36,9 +37,9 @@ public class DeepEntry {
 	
 	@Test
 	public void enterToSubstate() {
-		statemachine.enter();;
+		statemachine.enter();
 		long vergleich = 4l;
 		assertTrue(vergleich == 4l);
-		statemachine.exit();;
+		statemachine.exit();
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/DeepHistory.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.deephistory.DeepHistoryStatemachine;
-import org.yakindu.scr.deephistory.DeepHistoryStatemachine.State;
+import org.yakindu.scr.deephistory.DeepHistoryStatemachine.State;	
 
 /**
  * Unit TestCase for DeepHistory
  */
 @SuppressWarnings("all")
 public class DeepHistory {
+	
 	private DeepHistoryStatemachine statemachine;	
 	
 	@Before
@@ -36,23 +37,23 @@ public class DeepHistory {
 	
 	@Test
 	public void deepHistoryTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.raiseEvent3();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.raiseEvent5();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.raiseEvent7();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
 		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
 		statemachine.raiseEvent2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.mainRegion_State1));
 		assertTrue(!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
 		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/DynamicChoice.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.dynamicchoice.DynamicChoiceStatemachine;
-import org.yakindu.scr.dynamicchoice.DynamicChoiceStatemachine.State;
+import org.yakindu.scr.dynamicchoice.DynamicChoiceStatemachine.State;	
 
 /**
  * Unit TestCase for DynamicChoice
  */
 @SuppressWarnings("all")
 public class DynamicChoice {
+	
 	private DynamicChoiceStatemachine statemachine;	
 	
 	@Before
@@ -36,9 +37,9 @@ public class DynamicChoice {
 	
 	@Test
 	public void dynamicChoiceTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_Start));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/EmptyTransition.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.emptytransition.EmptyTransitionStatemachine;
-import org.yakindu.scr.emptytransition.EmptyTransitionStatemachine.State;
+import org.yakindu.scr.emptytransition.EmptyTransitionStatemachine.State;	
 
 /**
  * Unit TestCase for EmptyTransition
  */
 @SuppressWarnings("all")
 public class EmptyTransition {
+	
 	private EmptyTransitionStatemachine statemachine;	
 	
 	@Before
@@ -36,8 +37,8 @@ public class EmptyTransition {
 	
 	@Test
 	public void emptyTransitionTest() {
-		statemachine.enter();;
-		statemachine.runCycle();;
+		statemachine.enter();
+		statemachine.runCycle();
 		assertTrue(!statemachine.isStateActive(State.main_region_B));
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/EnterState.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.enterstate.EnterStateStatemachine;
-import org.yakindu.scr.enterstate.EnterStateStatemachine.State;
+import org.yakindu.scr.enterstate.EnterStateStatemachine.State;	
 
 /**
  * Unit TestCase for EnterState
  */
 @SuppressWarnings("all")
 public class EnterState {
+	
 	private EnterStateStatemachine statemachine;	
 	
 	@Before
@@ -36,26 +37,26 @@ public class EnterState {
 	
 	@Test
 	public void defaultEntry() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.r_A));
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r_B_r_E));
 	}
 	@Test
 	public void namedEntryThroughNamedTransition() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.r_A));
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r_B_r_F));
 	}
 	@Test
 	public void namedEntryThroughDefaultTransition() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.r_A));
 		statemachine.raiseG();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r_B_r_E));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/EntryChoice.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.entrychoice.EntryChoiceStatemachine;
-import org.yakindu.scr.entrychoice.EntryChoiceStatemachine.State;
+import org.yakindu.scr.entrychoice.EntryChoiceStatemachine.State;	
 
 /**
  * Unit TestCase for EntryChoice
  */
 @SuppressWarnings("all")
 public class EntryChoice {
+	
 	private EntryChoiceStatemachine statemachine;	
 	
 	@Before
@@ -36,9 +37,9 @@ public class EntryChoice {
 	
 	@Test
 	public void entryChoiceTest() {
-		statemachine.enter();;
-		statemachine.runCycle();;
-		statemachine.runCycle();;
+		statemachine.enter();
+		statemachine.runCycle();
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/EntryExitSelfTransition.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.entryexitselftransition.EntryExitSelfTransitionStatemachine;
-import org.yakindu.scr.entryexitselftransition.EntryExitSelfTransitionStatemachine.State;
+import org.yakindu.scr.entryexitselftransition.EntryExitSelfTransitionStatemachine.State;	
 
 /**
  * Unit TestCase for EntryExitSelfTransition
  */
 @SuppressWarnings("all")
 public class EntryExitSelfTransition {
+	
 	private EntryExitSelfTransitionStatemachine statemachine;	
 	
 	@Before
@@ -38,30 +39,30 @@ public class EntryExitSelfTransition {
 	public void selfTransitionToChildState() {
 		init();
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getEntries() == 1l);
 		assertTrue(statemachine.getExits() == 1l);
 		assertTrue(statemachine.isStateActive(State.main_region_A__region0_C));
-		statemachine.exit();;
+		statemachine.exit();
 	}
 	@Test
 	public void selfTransitionFromChildState() {
 		init();
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getEntries() == 0l);
 		assertTrue(statemachine.getExits() == 0l);
 		assertTrue(statemachine.isStateActive(State.main_region_A__region0_C));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A__region0_B));
 		assertTrue(statemachine.getEntries() == 1l);
 		assertTrue(statemachine.getExits() == 1l);
-		statemachine.exit();;
+		statemachine.exit();
 	}
 	public void init() {
-		statemachine.enter();;
-		statemachine.runCycle();;
+		statemachine.enter();
+		statemachine.runCycle();
 		assertTrue(statemachine.getEntries() == 1l);
 		assertTrue(statemachine.isStateActive(State.main_region_A__region0_B));
 		statemachine.setEntries(0l);

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/EntryReactionAction.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.entryreactionaction.EntryReactionActionStatemachine;
-import org.yakindu.scr.entryreactionaction.EntryReactionActionStatemachine.State;
+import org.yakindu.scr.entryreactionaction.EntryReactionActionStatemachine.State;	
 
 /**
  * Unit TestCase for EntryReactionAction
  */
 @SuppressWarnings("all")
 public class EntryReactionAction {
+	
 	private EntryReactionActionStatemachine statemachine;	
 	
 	@Before
@@ -36,7 +37,7 @@ public class EntryReactionAction {
 	
 	@Test
 	public void entryTransitionActionOnStatechartEnter() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.getEnteredR1());
 		assertTrue(statemachine.getEnteredR2());
 		assertTrue(statemachine.getEnteredBdefault());
@@ -46,7 +47,7 @@ public class EntryReactionAction {
 	public void entryOnRTS() {
 		init();
 		statemachine.raiseB();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.getEnteredR1());
 		assertTrue(!statemachine.getEnteredR2());
 		assertTrue(!statemachine.getEnteredBdefault());
@@ -56,18 +57,18 @@ public class EntryReactionAction {
 	public void noEntryTransitionActionOnHistory() {
 		init();
 		statemachine.raiseD();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.getEnteredR1());
 		assertTrue(!statemachine.getEnteredR2());
 		assertTrue(!statemachine.getEnteredBdefault());
 		assertTrue(!statemachine.getEnteredBother());
 	}
 	public void init() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.raiseB();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.raiseD();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.setEnteredR1(false);
 		statemachine.setEnteredR2(false);
 		statemachine.setEnteredBdefault(false);

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ExitOnSelfTransition.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.exitonselftransition.ExitOnSelfTransitionStatemachine;
-import org.yakindu.scr.exitonselftransition.ExitOnSelfTransitionStatemachine.State;
+import org.yakindu.scr.exitonselftransition.ExitOnSelfTransitionStatemachine.State;	
 
 /**
  * Unit TestCase for ExitOnSelfTransition
  */
 @SuppressWarnings("all")
 public class ExitOnSelfTransition {
+	
 	private ExitOnSelfTransitionStatemachine statemachine;	
 	
 	@Before
@@ -36,16 +37,16 @@ public class ExitOnSelfTransition {
 	
 	@Test
 	public void exitOnSelfTransitionTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		assertTrue(statemachine.getEntryCount() == 1l);
 		assertTrue(statemachine.getExitCount() == 0l);
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getEntryCount() == 2l);
 		assertTrue(statemachine.getExitCount() == 1l);
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getEntryCount() == 2l);
 		assertTrue(statemachine.getExitCount() == 2l);
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ExitState.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.exitstate.ExitStateStatemachine;
-import org.yakindu.scr.exitstate.ExitStateStatemachine.State;
+import org.yakindu.scr.exitstate.ExitStateStatemachine.State;	
 
 /**
  * Unit TestCase for ExitState
  */
 @SuppressWarnings("all")
 public class ExitState {
+	
 	private ExitStateStatemachine statemachine;	
 	
 	@Before
@@ -36,33 +37,33 @@ public class ExitState {
 	
 	@Test
 	public void defaultExit() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.r_A));
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r_E));
 	}
 	@Test
 	public void namedExitThroughNamedTransition() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.r_A));
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r_F));
 	}
 	@Test
 	public void namedExitThroughDefaultTransition() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.r_A));
 		statemachine.raiseG();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r_E));
 	}
 	@Test
 	public void remainInA() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.r_A));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r_A));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/FeatureCalls.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.featurecalls.FeatureCallsStatemachine;
-import org.yakindu.scr.featurecalls.FeatureCallsStatemachine.State;
+import org.yakindu.scr.featurecalls.FeatureCallsStatemachine.State;	
 
 /**
  * Unit TestCase for FeatureCalls
  */
 @SuppressWarnings("all")
 public class FeatureCalls {
+	
 	private FeatureCallsStatemachine statemachine;	
 	
 	@Before
@@ -36,9 +37,9 @@ public class FeatureCalls {
 	
 	@Test
 	public void featureCalls() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/FinalState.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.finalstate.FinalStateStatemachine;
-import org.yakindu.scr.finalstate.FinalStateStatemachine.State;
+import org.yakindu.scr.finalstate.FinalStateStatemachine.State;	
 
 /**
  * Unit TestCase for FinalState
  */
 @SuppressWarnings("all")
 public class FinalState {
+	
 	private FinalStateStatemachine statemachine;	
 	
 	@Before
@@ -36,8 +37,8 @@ public class FinalState {
 	
 	@Test
 	public void statechartNameTest() {
-		statemachine.enter();;
-		statemachine.runCycle();;
+		statemachine.enter();
+		statemachine.runCycle();
 		assertTrue(statemachine.isFinal());
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/Guard.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.guard.GuardStatemachine;
-import org.yakindu.scr.guard.GuardStatemachine.State;
+import org.yakindu.scr.guard.GuardStatemachine.State;	
 
 /**
  * Unit TestCase for Guard
  */
 @SuppressWarnings("all")
 public class Guard {
+	
 	private GuardStatemachine statemachine;	
 	
 	@Before
@@ -36,22 +37,22 @@ public class Guard {
 	
 	@Test
 	public void guardTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseEvent2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		statemachine.raiseReturn();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		statemachine.raiseReturn();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/GuardedEntry.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.guardedentry.GuardedEntryStatemachine;
-import org.yakindu.scr.guardedentry.GuardedEntryStatemachine.State;
+import org.yakindu.scr.guardedentry.GuardedEntryStatemachine.State;	
 
 /**
  * Unit TestCase for GuardedEntry
  */
 @SuppressWarnings("all")
 public class GuardedEntry {
+	
 	private GuardedEntryStatemachine statemachine;	
 	
 	@Before
@@ -37,14 +38,14 @@ public class GuardedEntry {
 	@Test
 	public void entryNotTakenOnStatechartEnter() {
 		assertTrue(statemachine.getGuard() == false);
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		assertTrue(statemachine.getDone() == false);
 	}
 	@Test
 	public void entryTakenOnStatechartEnter() {
 		statemachine.setGuard(true);
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		assertTrue(statemachine.getDone() == true);
 	}
@@ -59,15 +60,15 @@ public class GuardedEntry {
 		assertTrue(!statemachine.getDone());
 	}
 	public void initEntryInTransition(boolean guardVar, boolean doneVar) {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		statemachine.setGuard(guardVar);
 		statemachine.setDone(doneVar);
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/GuardedExit.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.guardedexit.GuardedExitStatemachine;
-import org.yakindu.scr.guardedexit.GuardedExitStatemachine.State;
+import org.yakindu.scr.guardedexit.GuardedExitStatemachine.State;	
 
 /**
  * Unit TestCase for GuardedExit
  */
 @SuppressWarnings("all")
 public class GuardedExit {
+	
 	private GuardedExitStatemachine statemachine;	
 	
 	@Before
@@ -36,21 +37,21 @@ public class GuardedExit {
 	
 	@Test
 	public void exitTaken() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		assertTrue(!statemachine.getGuard());
 		checkDone(false);
 	}
 	@Test
 	public void exitNotTaken() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.setGuard(true);
 		checkDone(true);
 	}
 	public void checkDone(boolean shouldBeDone) {
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		assertTrue(shouldBeDone ? statemachine.getDone()  : !statemachine.getDone());
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/HistoryWithExitPoint.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.historywithexitpoint.HistoryWithExitPointStatemachine;
-import org.yakindu.scr.historywithexitpoint.HistoryWithExitPointStatemachine.State;
+import org.yakindu.scr.historywithexitpoint.HistoryWithExitPointStatemachine.State;	
 
 /**
  * Unit TestCase for HistoryWithExitPoint
  */
 @SuppressWarnings("all")
 public class HistoryWithExitPoint {
+	
 	private HistoryWithExitPointStatemachine statemachine;	
 	
 	@Before
@@ -36,22 +37,22 @@ public class HistoryWithExitPoint {
 	
 	@Test
 	public void historyEntryAfterExit() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.mr_A_r_X1));
 		statemachine.raisePush();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.mr_B));
 		statemachine.raiseBack();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.mr_A_r_X1));
 		statemachine.raiseNext();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.mr_A_r_X2));
 		statemachine.raisePush();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.mr_B));
 		statemachine.raiseBack();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.mr_A_r_X2));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/HistoryWithoutInitialStep.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.historywithoutinitialstep.HistoryWithoutInitialStepStatemachine;
-import org.yakindu.scr.historywithoutinitialstep.HistoryWithoutInitialStepStatemachine.State;
+import org.yakindu.scr.historywithoutinitialstep.HistoryWithoutInitialStepStatemachine.State;	
 
 /**
  * Unit TestCase for HistoryWithoutInitialStep
  */
 @SuppressWarnings("all")
 public class HistoryWithoutInitialStep {
+	
 	private HistoryWithoutInitialStepStatemachine statemachine;	
 	
 	@Before
@@ -39,7 +40,7 @@ public class HistoryWithoutInitialStep {
 		init();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
 		statemachine.raiseNext();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
 	}
 	@Test
@@ -47,29 +48,29 @@ public class HistoryWithoutInitialStep {
 		init();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
 		statemachine.raiseToA();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseToHistory();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
 	}
 	@Test
 	public void enterDThroughHistory() {
 		init();
 		statemachine.raiseNext();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
 		statemachine.raiseToA();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseToHistory();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
 	}
 	public void init() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseToB();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/InEventLifeCycle.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.ineventlifecycle.InEventLifeCycleStatemachine;
-import org.yakindu.scr.ineventlifecycle.InEventLifeCycleStatemachine.State;
+import org.yakindu.scr.ineventlifecycle.InEventLifeCycleStatemachine.State;	
 
 /**
  * Unit TestCase for InEventLifeCycle
  */
 @SuppressWarnings("all")
 public class InEventLifeCycle {
+	
 	private InEventLifeCycleStatemachine statemachine;	
 	
 	@Before
@@ -36,10 +37,10 @@ public class InEventLifeCycle {
 	
 	@Test
 	public void eventLifeCycle() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.raiseE();
 		assertTrue(statemachine.getI() == 0l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getI() == 1l);
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/IntegerExpressions.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.integerexpressions.IntegerExpressionsStatemachine;
-import org.yakindu.scr.integerexpressions.IntegerExpressionsStatemachine.State;
+import org.yakindu.scr.integerexpressions.IntegerExpressionsStatemachine.State;	
 
 /**
  * Unit TestCase for IntegerExpressions
  */
 @SuppressWarnings("all")
 public class IntegerExpressions {
+	
 	private IntegerExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -36,12 +37,12 @@ public class IntegerExpressions {
 	
 	@Test
 	public void integerExpressions() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_StateA));
 		assertTrue(statemachine.getMyInt1() == 10l);
 		assertTrue(statemachine.getMyInt2() == 5l);
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getLess() == false);
 		assertTrue(statemachine.getGreater() == true);
 		assertTrue(statemachine.getEqualOrLess() == false);

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/InternalEventLifeCycle.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.internaleventlifecycle.InternalEventLifeCycleStatemachine;
-import org.yakindu.scr.internaleventlifecycle.InternalEventLifeCycleStatemachine.State;
+import org.yakindu.scr.internaleventlifecycle.InternalEventLifeCycleStatemachine.State;	
 
 /**
  * Unit TestCase for InternalEventLifeCycle
  */
 @SuppressWarnings("all")
 public class InternalEventLifeCycle {
+	
 	private InternalEventLifeCycleStatemachine statemachine;	
 	
 	@Before
@@ -36,21 +37,21 @@ public class InternalEventLifeCycle {
 	
 	@Test
 	public void internalEventLifeCycleTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.r1_A));
 		assertTrue(statemachine.isStateActive(State.r2_C));
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r1_A));
 		assertTrue(statemachine.isStateActive(State.r2_D));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r1_A));
 		assertTrue(statemachine.isStateActive(State.r2_D));
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r1_A));
 		assertTrue(statemachine.isStateActive(State.r2_C));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r1_A));
 		assertTrue(statemachine.isStateActive(State.r2_C));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/LocalReactions.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.localreactions.LocalReactionsStatemachine;
-import org.yakindu.scr.localreactions.LocalReactionsStatemachine.State;
+import org.yakindu.scr.localreactions.LocalReactionsStatemachine.State;	
 
 /**
  * Unit TestCase for LocalReactions
  */
 @SuppressWarnings("all")
 public class LocalReactions {
+	
 	private LocalReactionsStatemachine statemachine;	
 	
 	@Before
@@ -36,9 +37,9 @@ public class LocalReactions {
 	
 	@Test
 	public void localReactionsTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getX() == 1l);
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/LogicalAndTests.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.logicaland.LogicalAndStatemachine;
-import org.yakindu.scr.logicaland.LogicalAndStatemachine.State;
+import org.yakindu.scr.logicaland.LogicalAndStatemachine.State;	
 
 /**
  * Unit TestCase for LogicalAnd
  */
 @SuppressWarnings("all")
 public class LogicalAndTests {
+	
 	private LogicalAndStatemachine statemachine;	
 	
 	@Before
@@ -36,8 +37,8 @@ public class LogicalAndTests {
 	
 	@Test
 	public void operandEvaluationOrder() {
-		statemachine.enter();;
-		statemachine.runCycle();;
+		statemachine.enter();
+		statemachine.runCycle();
 		assertTrue("logical and expression was executed in wrong order...",statemachine.getX() == 4l && statemachine.getB());
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/LogicalOrTests.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.logicalor.LogicalOrStatemachine;
-import org.yakindu.scr.logicalor.LogicalOrStatemachine.State;
+import org.yakindu.scr.logicalor.LogicalOrStatemachine.State;	
 
 /**
  * Unit TestCase for LogicalOr
  */
 @SuppressWarnings("all")
 public class LogicalOrTests {
+	
 	private LogicalOrStatemachine statemachine;	
 	
 	@Before
@@ -36,8 +37,8 @@ public class LogicalOrTests {
 	
 	@Test
 	public void operandEvaluationOrder() {
-		statemachine.enter();;
-		statemachine.runCycle();;
+		statemachine.enter();
+		statemachine.runCycle();
 		assertTrue("logical or expression was executed in wrong order...",statemachine.getX() == 4l && statemachine.getB());
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/NamedInterfaceAccess.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.namedinterfaceaccess.NamedInterfaceAccessStatemachine;
-import org.yakindu.scr.namedinterfaceaccess.NamedInterfaceAccessStatemachine.State;
+import org.yakindu.scr.namedinterfaceaccess.NamedInterfaceAccessStatemachine.State;	
 
 /**
  * Unit TestCase for NamedInterfaceAccess
  */
 @SuppressWarnings("all")
 public class NamedInterfaceAccess {
+	
 	private NamedInterfaceAccessStatemachine statemachine;	
 	
 	@Before
@@ -36,14 +37,14 @@ public class NamedInterfaceAccess {
 	
 	@Test
 	public void safeOpenSuccess() {
-		statemachine.enter();;
-		statemachine.runCycle();;
+		statemachine.enter();
+		statemachine.runCycle();
 		statemachine.getSCIUser().raiseNumberPressed(3l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.getSCIUser().raiseNumberPressed(7l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.getSCIUser().raiseNumberPressed(5l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.getSCISafe().isRaisedOpen());
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/NullCheck.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.nullcheck.NullCheckStatemachine;
-import org.yakindu.scr.nullcheck.NullCheckStatemachine.State;
+import org.yakindu.scr.nullcheck.NullCheckStatemachine.State;	
 
 /**
  * Unit TestCase for NullCheck
  */
 @SuppressWarnings("all")
 public class NullCheck {
+	
 	private NullCheckStatemachine statemachine;	
 	
 	@Before
@@ -36,9 +37,9 @@ public class NullCheck {
 	
 	@Test
 	public void simpleNullCheckTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/OperationsTest.java

@@ -20,7 +20,7 @@ import static org.mockito.ArgumentCaptor.forClass;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.operations.OperationsStatemachine;
-import org.yakindu.scr.operations.OperationsStatemachine.State;
+import org.yakindu.scr.operations.OperationsStatemachine.State;	
 
 /**
  * Unit TestCase for Operations
@@ -30,6 +30,7 @@ public class OperationsTest {
 	SCInterfaceOperationCallback defaultMock;
 	InternalOperationCallback internalMock;
 	SCIInterface1OperationCallback interface1Mock;
+	
 	private OperationsStatemachine statemachine;	
 	
 	@Before
@@ -56,9 +57,9 @@ public class OperationsTest {
 	public void operationsCalled() {
 		when(defaultMock.alwaysTrue()).thenReturn(true);
 		 
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		verify(internalMock, atLeastOnce()).internalOperation1();
 		 
@@ -84,7 +85,7 @@ public class OperationsTest {
 		verify(internalMock, atLeastOnce()).internalOperation5a(stringCaptureinternalOperation5a_12_0.capture());
 		 
 		statemachine.raiseEv();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_C));
 		verify(interface1Mock, atLeastOnce()).interfaceOperation1();
 		 
@@ -110,7 +111,7 @@ public class OperationsTest {
 		verify(interface1Mock, atLeastOnce()).interfaceOperation5a(stringCaptureinterfaceOperation5a_23_0.capture());
 		 
 		statemachine.raiseEv();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_D));
 		verify(defaultMock, atLeastOnce()).unnamedInterfaceOperation1();
 		 

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/OperationsWithoutBraces.java

@@ -20,7 +20,7 @@ import static org.mockito.ArgumentCaptor.forClass;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.operationswithoutbraces.OperationsWithoutBracesStatemachine;
-import org.yakindu.scr.operationswithoutbraces.OperationsWithoutBracesStatemachine.State;
+import org.yakindu.scr.operationswithoutbraces.OperationsWithoutBracesStatemachine.State;	
 
 /**
  * Unit TestCase for OperationsWithoutBraces
@@ -28,6 +28,7 @@ import org.yakindu.scr.operationswithoutbraces.OperationsWithoutBracesStatemachi
 @SuppressWarnings("all")
 public class OperationsWithoutBraces {
 	SCInterfaceOperationCallback defaultMock;
+	
 	private OperationsWithoutBracesStatemachine statemachine;	
 	
 	@Before
@@ -52,13 +53,13 @@ public class OperationsWithoutBraces {
 		 
 		when(defaultMock.myRealOp()).thenReturn(0.0);
 		 
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.another_region_A));
 		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.another_region_C));
 		assertTrue(statemachine.isStateActive(State.main_region_C));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_D));
 		assertTrue(statemachine.isStateActive(State.another_region_D));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/OutEventLifeCycle.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.outeventlifecycle.OutEventLifeCycleStatemachine;
-import org.yakindu.scr.outeventlifecycle.OutEventLifeCycleStatemachine.State;
+import org.yakindu.scr.outeventlifecycle.OutEventLifeCycleStatemachine.State;	
 
 /**
  * Unit TestCase for OutEventLifeCycle
  */
 @SuppressWarnings("all")
 public class OutEventLifeCycle {
+	
 	private OutEventLifeCycleStatemachine statemachine;	
 	
 	@Before
@@ -36,9 +37,9 @@ public class OutEventLifeCycle {
 	
 	@Test
 	public void availableAfterCycle() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isRaisedF());
 	}
 	@Test
@@ -57,11 +58,11 @@ public class OutEventLifeCycle {
 		assertTrue(!statemachine.isRaisedF());
 	}
 	public void init(boolean sndCycle) {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		if (sndCycle) {
-			statemachine.runCycle();;
+			statemachine.runCycle();
 		}
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/Parenthesis.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.parenthesis.ParenthesisStatemachine;
-import org.yakindu.scr.parenthesis.ParenthesisStatemachine.State;
+import org.yakindu.scr.parenthesis.ParenthesisStatemachine.State;	
 
 /**
  * Unit TestCase for Parenthesis
  */
 @SuppressWarnings("all")
 public class Parenthesis {
+	
 	private ParenthesisStatemachine statemachine;	
 	
 	@Before
@@ -36,7 +37,7 @@ public class Parenthesis {
 	
 	@Test
 	public void simple() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.mainRegion_A));
 		assertTrue(statemachine.getErg() == 8l);
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/PerformanceTests.java

@@ -14,20 +14,23 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.performancetest.PerformanceTestStatemachine;
-import org.yakindu.scr.performancetest.PerformanceTestStatemachine.State;
-import org.yakindu.scr.TimerService;
+import org.yakindu.scr.performancetest.PerformanceTestStatemachine.State;	
+import org.yakindu.scr.VirtualTimer;
 
 /**
  * Unit TestCase for PerformanceTest
  */
 @SuppressWarnings("all")
 public class PerformanceTests {
+	
 	private PerformanceTestStatemachine statemachine;	
+	private VirtualTimer timer;
 	
 	@Before
 	public void setUp() {
 		statemachine = new PerformanceTestStatemachine();
-		statemachine.setTimer(new TimerService());
+		timer = new VirtualTimer();
+		statemachine.setTimer(timer);
 		statemachine.init();
 	}
 
@@ -49,7 +52,7 @@ public class PerformanceTests {
 		performance(10000000l);
 	}
 	public void performance(long perf) {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.mr_A));
 		while (statemachine.getC() < perf) {
 			if (statemachine.isStateActive(State.mr_A)) {
@@ -63,7 +66,7 @@ public class PerformanceTests {
 					statemachine.raiseE3();
 				}
 			}
-			statemachine.runCycle();;
+			statemachine.runCycle();
 		}
 		assertTrue(statemachine.getA() > 2l);
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/PriorityValues.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.priorityvalues.PriorityValuesStatemachine;
-import org.yakindu.scr.priorityvalues.PriorityValuesStatemachine.State;
+import org.yakindu.scr.priorityvalues.PriorityValuesStatemachine.State;	
 
 /**
  * Unit TestCase for PriorityValues
  */
 @SuppressWarnings("all")
 public class PriorityValues {
+	
 	private PriorityValuesStatemachine statemachine;	
 	
 	@Before
@@ -36,18 +37,18 @@ public class PriorityValues {
 	
 	@Test
 	public void transitionPriority() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_C));
 	}
 	@Test
 	public void regionPriority() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.someRegion_A));
 		statemachine.raiseEvent2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.someRegion_B));
 		assertTrue(!statemachine.isStateActive(State.main_region_E));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/RaiseEvent.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.raiseevent.RaiseEventStatemachine;
-import org.yakindu.scr.raiseevent.RaiseEventStatemachine.State;
+import org.yakindu.scr.raiseevent.RaiseEventStatemachine.State;	
 
 /**
  * Unit TestCase for RaiseEvent
  */
 @SuppressWarnings("all")
 public class RaiseEvent {
+	
 	private RaiseEventStatemachine statemachine;	
 	
 	@Before
@@ -36,12 +37,12 @@ public class RaiseEvent {
 	
 	@Test
 	public void raiseEvent() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.second_region_SateA));
 		assertTrue(statemachine.isStateActive(State.main_region_StateA));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
-		statemachine.runCycle();;
+		statemachine.runCycle();
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.second_region_StateB));
 		assertTrue(statemachine.isStateActive(State.main_region_StateB));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ReadOnlyVariable.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.readonlyvariable.ReadOnlyVariableStatemachine;
-import org.yakindu.scr.readonlyvariable.ReadOnlyVariableStatemachine.State;
+import org.yakindu.scr.readonlyvariable.ReadOnlyVariableStatemachine.State;	
 
 /**
  * Unit TestCase for ReadOnlyVariable
  */
 @SuppressWarnings("all")
 public class ReadOnlyVariable {
+	
 	private ReadOnlyVariableStatemachine statemachine;	
 	
 	@Before
@@ -36,7 +37,7 @@ public class ReadOnlyVariable {
 	
 	@Test
 	public void readOnlyVariableTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_StateA));
 		assertTrue(statemachine.getMyInt() == 0l);
 		assertTrue(statemachine.getMyString().equals("testString"));
@@ -46,7 +47,7 @@ public class ReadOnlyVariable {
 		assertTrue(statemachine.getSCIA().getMyString().equals("testString"));
 		assertTrue(statemachine.getSCIA().getMyBool() == true);
 		assertTrue(statemachine.getSCIA().getMyReal() == 1.1);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_StateB));
 		assertTrue(statemachine.getMyInt() == 100l);
 		assertTrue(statemachine.getMyString().equals("fail"));

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/STextKeywordsInStatesAndRegions.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.stextkeywordsinstatesandregions.STextKeywordsInStatesAndRegionsStatemachine;
-import org.yakindu.scr.stextkeywordsinstatesandregions.STextKeywordsInStatesAndRegionsStatemachine.State;
+import org.yakindu.scr.stextkeywordsinstatesandregions.STextKeywordsInStatesAndRegionsStatemachine.State;	
 
 /**
  * Unit TestCase for STextKeywordsInStatesAndRegions
  */
 @SuppressWarnings("all")
 public class STextKeywordsInStatesAndRegions {
+	
 	private STextKeywordsInStatesAndRegionsStatemachine statemachine;	
 	
 	@Before
@@ -36,7 +37,7 @@ public class STextKeywordsInStatesAndRegions {
 	
 	@Test
 	public void activeCheckWithSTextNamedStates() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_interface));
 		assertTrue(statemachine.isStateActive(State.namespace_event));
@@ -58,7 +59,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_event));
@@ -80,7 +81,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -102,7 +103,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -124,7 +125,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -146,7 +147,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -168,7 +169,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -190,7 +191,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -212,7 +213,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -234,7 +235,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -256,7 +257,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -278,7 +279,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -300,7 +301,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -322,7 +323,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -344,7 +345,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -366,7 +367,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -388,7 +389,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -410,7 +411,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -432,7 +433,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_always));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -454,7 +455,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_oncycle));
 		assertTrue(statemachine.isStateActive(State.active_raise));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));
@@ -476,7 +477,7 @@ public class STextKeywordsInStatesAndRegions {
 		assertTrue(statemachine.isStateActive(State.valueof_oncycle));
 		assertTrue(statemachine.isStateActive(State.active_valueof));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_internal));
 		assertTrue(statemachine.isStateActive(State.namespace_local));

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/SameNameDifferentRegion.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.samenamedifferentregion.SameNameDifferentRegionStatemachine;
-import org.yakindu.scr.samenamedifferentregion.SameNameDifferentRegionStatemachine.State;
+import org.yakindu.scr.samenamedifferentregion.SameNameDifferentRegionStatemachine.State;	
 
 /**
  * Unit TestCase for SameNameDifferentRegion
  */
 @SuppressWarnings("all")
 public class SameNameDifferentRegion {
+	
 	private SameNameDifferentRegionStatemachine statemachine;	
 	
 	@Before
@@ -36,14 +37,14 @@ public class SameNameDifferentRegion {
 	
 	@Test
 	public void sameNameDifferenRegionTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_StateA));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_StateB));
 		assertTrue(statemachine.isStateActive(State.main_region_StateB_r1_StateA));
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_StateB));
 		assertTrue(statemachine.isStateActive(State.main_region_StateB_r1_StateB));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ShallowHistory.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.shallowhistory.ShallowHistoryStatemachine;
-import org.yakindu.scr.shallowhistory.ShallowHistoryStatemachine.State;
+import org.yakindu.scr.shallowhistory.ShallowHistoryStatemachine.State;	
 
 /**
  * Unit TestCase for ShallowHistory
  */
 @SuppressWarnings("all")
 public class ShallowHistory {
+	
 	private ShallowHistoryStatemachine statemachine;	
 	
 	@Before
@@ -36,35 +37,35 @@ public class ShallowHistory {
 	
 	@Test
 	public void shallowHistoryTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.raiseEvent3();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.raiseEvent5();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.raiseEvent7();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
 		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
 		statemachine.raiseEvent6();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
 		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State6));
 		statemachine.raiseEvent5();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State8));
 		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
 		statemachine.raiseEvent2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
 		assertTrue(statemachine.isStateActive(State.mainRegion_State1));
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State6));
 		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
 		statemachine.raiseEvent5();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State6));
 		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ShallowHistoryWithDeepEntry.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.shallowhistorywithdeepentry.ShallowHistoryWithDeepEntryStatemachine;
-import org.yakindu.scr.shallowhistorywithdeepentry.ShallowHistoryWithDeepEntryStatemachine.State;
+import org.yakindu.scr.shallowhistorywithdeepentry.ShallowHistoryWithDeepEntryStatemachine.State;	
 
 /**
  * Unit TestCase for ShallowHistoryWithDeepEntry
  */
 @SuppressWarnings("all")
 public class ShallowHistoryWithDeepEntry {
+	
 	private ShallowHistoryWithDeepEntryStatemachine statemachine;	
 	
 	@Before
@@ -36,50 +37,50 @@ public class ShallowHistoryWithDeepEntry {
 	
 	@Test
 	public void noDeepEntryWithinHistory() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_Y));
 		statemachine.raiseToZ();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_A));
 		statemachine.raiseToY();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Y));
 		statemachine.raiseToZ();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_A));
 	}
 	@Test
 	public void deepEntryWithinHistory() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_Y));
 		statemachine.raiseToZ();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_A));
 		statemachine.raiseToC();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B__region0_C));
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B));
 		statemachine.raiseToY();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Y));
 		statemachine.raiseToZ();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B__region0_C));
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B));
 	}
 	@Test
 	public void directDeepEntryIntoHistory() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_Y));
 		statemachine.raiseToC();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B__region0_C));
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B));
 		statemachine.raiseToY();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Y));
 		statemachine.raiseToZ();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B__region0_C));
 		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/SimpleEvent.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.simpleevent.SimpleEventStatemachine;
-import org.yakindu.scr.simpleevent.SimpleEventStatemachine.State;
+import org.yakindu.scr.simpleevent.SimpleEventStatemachine.State;	
 
 /**
  * Unit TestCase for SimpleEvent
  */
 @SuppressWarnings("all")
 public class SimpleEvent {
+	
 	private SimpleEventStatemachine statemachine;	
 	
 	@Before
@@ -36,13 +37,13 @@ public class SimpleEvent {
 	
 	@Test
 	public void simpleEventTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue("Expected A to be active",statemachine.isStateActive(State.main_region_A));
 		assertTrue(5l == 5l);
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue("Expected B to be active",statemachine.isStateActive(State.main_region_B));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.isStateActive(State.main_region_B));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/SimpleHierachy.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.simplehierachy.SimpleHierachyStatemachine;
-import org.yakindu.scr.simplehierachy.SimpleHierachyStatemachine.State;
+import org.yakindu.scr.simplehierachy.SimpleHierachyStatemachine.State;	
 
 /**
  * Unit TestCase for SimpleHierachy
  */
 @SuppressWarnings("all")
 public class SimpleHierachy {
+	
 	private SimpleHierachyStatemachine statemachine;	
 	
 	@Before
@@ -36,12 +37,12 @@ public class SimpleHierachy {
 	
 	@Test
 	public void simpleHierachyTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseEvent1();
 		statemachine.raiseEvent1();
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		assertTrue(statemachine.isStateActive(State.main_region_B_subregion1_B1));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/StateIsActive.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.stateisactive.StateIsActiveStatemachine;
-import org.yakindu.scr.stateisactive.StateIsActiveStatemachine.State;
+import org.yakindu.scr.stateisactive.StateIsActiveStatemachine.State;	
 
 /**
  * Unit TestCase for StateIsActive
  */
 @SuppressWarnings("all")
 public class StateIsActive {
+	
 	private StateIsActiveStatemachine statemachine;	
 	
 	@Before
@@ -36,12 +37,12 @@ public class StateIsActive {
 	
 	@Test
 	public void stateIsActive() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.r1_R1A));
 		assertTrue(statemachine.isStateActive(State.r2_R2A));
 		statemachine.raiseEvent1();
-		statemachine.runCycle();;
-		statemachine.runCycle();;
+		statemachine.runCycle();
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.r1_R1B));
 		assertTrue(statemachine.isStateActive(State.r2_R2B));
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/StatechartActive.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.statechartactive.StatechartActiveStatemachine;
-import org.yakindu.scr.statechartactive.StatechartActiveStatemachine.State;
+import org.yakindu.scr.statechartactive.StatechartActiveStatemachine.State;	
 
 /**
  * Unit TestCase for StatechartActive
  */
 @SuppressWarnings("all")
 public class StatechartActive {
+	
 	private StatechartActiveStatemachine statemachine;	
 	
 	@Before
@@ -40,20 +41,20 @@ public class StatechartActive {
 	}
 	@Test
 	public void activeAfterEnter() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isActive());
 	}
 	@Test
 	public void inactiveAfterExit() {
-		statemachine.enter();;
-		statemachine.exit();;
+		statemachine.enter();
+		statemachine.exit();
 		assertTrue(!statemachine.isActive());
 	}
 	@Test
 	public void activeAfterReenter() {
-		statemachine.enter();;
-		statemachine.exit();;
-		statemachine.enter();;
+		statemachine.enter();
+		statemachine.exit();
+		statemachine.enter();
 		assertTrue(statemachine.isActive());
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/StatechartLocalReactions.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.statechartlocalreactions.StatechartLocalReactionsStatemachine;
-import org.yakindu.scr.statechartlocalreactions.StatechartLocalReactionsStatemachine.State;
+import org.yakindu.scr.statechartlocalreactions.StatechartLocalReactionsStatemachine.State;	
 
 /**
  * Unit TestCase for StatechartLocalReactions
  */
 @SuppressWarnings("all")
 public class StatechartLocalReactions {
+	
 	private StatechartLocalReactionsStatemachine statemachine;	
 	
 	@Before
@@ -36,7 +37,7 @@ public class StatechartLocalReactions {
 	
 	@Test
 	public void statechartLocalReactionsTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_S1));
 		assertTrue(statemachine.isStateActive(State.region2_a));
 		while (statemachine.getMyInt() < 10l) {
@@ -47,7 +48,7 @@ public class StatechartLocalReactions {
 			else {
 				assertTrue(statemachine.isStateActive(State.main_region_S2));
 			}
-			statemachine.runCycle();;
+			statemachine.runCycle();
 		}
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/StatemachineKeywords.java

@@ -14,20 +14,23 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.statechartkeywords.StatechartKeywordsStatemachine;
-import org.yakindu.scr.statechartkeywords.StatechartKeywordsStatemachine.State;
-import org.yakindu.scr.TimerService;
+import org.yakindu.scr.statechartkeywords.StatechartKeywordsStatemachine.State;	
+import org.yakindu.scr.VirtualTimer;
 
 /**
  * Unit TestCase for StatechartKeywords
  */
 @SuppressWarnings("all")
 public class StatemachineKeywords {
+	
 	private StatechartKeywordsStatemachine statemachine;	
+	private VirtualTimer timer;
 	
 	@Before
 	public void setUp() {
 		statemachine = new StatechartKeywordsStatemachine();
-		statemachine.setTimer(new TimerService());
+		timer = new VirtualTimer();
+		statemachine.setTimer(timer);
 		statemachine.init();
 	}
 
@@ -38,7 +41,7 @@ public class StatemachineKeywords {
 	
 	@Test
 	public void statemachineKeywords() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_Timer));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/StaticChoice.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.staticchoice.StaticChoiceStatemachine;
-import org.yakindu.scr.staticchoice.StaticChoiceStatemachine.State;
+import org.yakindu.scr.staticchoice.StaticChoiceStatemachine.State;	
 
 /**
  * Unit TestCase for StaticChoice
  */
 @SuppressWarnings("all")
 public class StaticChoice {
+	
 	private StaticChoiceStatemachine statemachine;	
 	
 	@Before
@@ -36,8 +37,8 @@ public class StaticChoice {
 	
 	@Test
 	public void staticChoiceTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_Start));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/StringExpressions.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.stringexpressions.StringExpressionsStatemachine;
-import org.yakindu.scr.stringexpressions.StringExpressionsStatemachine.State;
+import org.yakindu.scr.stringexpressions.StringExpressionsStatemachine.State;	
 
 /**
  * Unit TestCase for StringExpressions
  */
 @SuppressWarnings("all")
 public class StringExpressions {
+	
 	private StringExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -38,31 +39,31 @@ public class StringExpressions {
 	public void stringExpressionsTest() {
 		assertTrue(statemachine.getQuotedStringX().equals("\"X\""));
 		assertTrue(statemachine.getQuotedStringY().equals("\"Y\""));
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_AssignmentChecked));
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_VarToVarCompareSucceeded));
 		assertTrue(statemachine.getGuardStringEqual());
 		assertTrue(statemachine.getGuardStringNotEqual());
 		assertTrue(statemachine.getStringVarEqual());
 		assertTrue(statemachine.getStringVarNotEqual());
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_VarToConstCompareSucceeded));
 		assertTrue(statemachine.getGuardStringEqual());
 		assertTrue(statemachine.getGuardStringNotEqual());
 		assertTrue(statemachine.getStringVarEqual());
 		assertTrue(statemachine.getStringVarNotEqual());
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_ConstToVarCompareSucceeded));
 		assertTrue(statemachine.getGuardStringEqual());
 		assertTrue(statemachine.getGuardStringNotEqual());
 		assertTrue(statemachine.getStringVarEqual());
 		assertTrue(statemachine.getStringVarNotEqual());
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_ConstToConstCompareSucceeded));
 		assertTrue(statemachine.getGuardStringEqual());
 		assertTrue(statemachine.getGuardStringNotEqual());

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/SyncFork.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.syncfork.SyncForkStatemachine;
-import org.yakindu.scr.syncfork.SyncForkStatemachine.State;
+import org.yakindu.scr.syncfork.SyncForkStatemachine.State;	
 
 /**
  * Unit TestCase for SyncFork
  */
 @SuppressWarnings("all")
 public class SyncFork {
+	
 	private SyncForkStatemachine statemachine;	
 	
 	@Before
@@ -36,23 +37,23 @@ public class SyncFork {
 	
 	@Test
 	public void syncForkTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/SyncJoin.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.syncjoin.SyncJoinStatemachine;
-import org.yakindu.scr.syncjoin.SyncJoinStatemachine.State;
+import org.yakindu.scr.syncjoin.SyncJoinStatemachine.State;	
 
 /**
  * Unit TestCase for SyncJoin
  */
 @SuppressWarnings("all")
 public class SyncJoin {
+	
 	private SyncJoinStatemachine statemachine;	
 	
 	@Before
@@ -36,81 +37,81 @@ public class SyncJoin {
 	
 	@Test
 	public void syncJoin_C2_Waits() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
 		statemachine.raiseJc();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
 		statemachine.raiseJd();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
 		statemachine.raiseJc();
 		statemachine.raiseJd();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
 		statemachine.raiseJc();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
 		statemachine.raiseJd();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
 		statemachine.raiseJc();
 		statemachine.raiseJd();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 	}
 	@Test
 	public void syncJoin_D2_Waits() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
 		statemachine.raiseJc();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
 		statemachine.raiseJd();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
 		statemachine.raiseJc();
 		statemachine.raiseJd();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
 		statemachine.raiseE();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
 		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
 	}
 	@Test
 	public void doubleEntryActionBug() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.raiseE();
 		statemachine.raiseF();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		statemachine.raiseJc();
 		statemachine.raiseJd();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		assertTrue(statemachine.getX() == 1l);
 	}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/TimedTransitions.java

@@ -14,20 +14,23 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.timedtransitions.TimedTransitionsStatemachine;
-import org.yakindu.scr.timedtransitions.TimedTransitionsStatemachine.State;
-import org.yakindu.scr.TimerService;
+import org.yakindu.scr.timedtransitions.TimedTransitionsStatemachine.State;	
+import org.yakindu.scr.VirtualTimer;
 
 /**
  * Unit TestCase for TimedTransitions
  */
 @SuppressWarnings("all")
 public class TimedTransitions {
+	
 	private TimedTransitionsStatemachine statemachine;	
+	private VirtualTimer timer;
 	
 	@Before
 	public void setUp() {
 		statemachine = new TimedTransitionsStatemachine();
-		statemachine.setTimer(new TimerService());
+		timer = new VirtualTimer();
+		statemachine.setTimer(timer);
 		statemachine.init();
 	}
 
@@ -38,8 +41,10 @@ public class TimedTransitions {
 	
 	@Test
 	public void timer01() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_Start));
+		timer.timeLeap(2030);
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_End));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/TransitionWithoutCondition.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.transitionwithoutcondition.TransitionWithoutConditionStatemachine;
-import org.yakindu.scr.transitionwithoutcondition.TransitionWithoutConditionStatemachine.State;
+import org.yakindu.scr.transitionwithoutcondition.TransitionWithoutConditionStatemachine.State;	
 
 /**
  * Unit TestCase for TransitionWithoutCondition
  */
 @SuppressWarnings("all")
 public class TransitionWithoutCondition {
+	
 	private TransitionWithoutConditionStatemachine statemachine;	
 	
 	@Before
@@ -36,9 +37,9 @@ public class TransitionWithoutCondition {
 	
 	@Test
 	public void transitionWithoutConditionTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/TriggerExpressionPrecedence.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceStatemachine;
-import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceStatemachine.State;
+import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceStatemachine.State;	
 
 /**
  * Unit TestCase for TriggerExpressionPrecedence
  */
 @SuppressWarnings("all")
 public class TriggerExpressionPrecedence {
+	
 	private TriggerExpressionPrecedenceStatemachine statemachine;	
 	
 	@Before
@@ -36,34 +37,34 @@ public class TriggerExpressionPrecedence {
 	
 	@Test
 	public void unsatisfiedTriggerAndFGuardFalseOrFalse() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.setC1(false);
 		statemachine.setC2(false);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.getE1_transition());
 	}
 	@Test
 	public void unsatisfiedTriggerAndFGuardTrueOrFalse() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.setC1(true);
 		statemachine.setC2(false);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.getE1_transition());
 	}
 	@Test
 	public void unsatisfiedTriggerAndFGuardFalseOrTrue() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.setC1(false);
 		statemachine.setC2(true);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.getE1_transition());
 	}
 	@Test
 	public void unsatisfiedTriggerAndFGuardTrueOrTrue() {
-		statemachine.enter();;
+		statemachine.enter();
 		statemachine.setC1(true);
 		statemachine.setC2(true);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(!statemachine.getE1_transition());
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/TriggerGuardExpressions.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.triggerguardexpressions.TriggerGuardExpressionsStatemachine;
-import org.yakindu.scr.triggerguardexpressions.TriggerGuardExpressionsStatemachine.State;
+import org.yakindu.scr.triggerguardexpressions.TriggerGuardExpressionsStatemachine.State;	
 
 /**
  * Unit TestCase for TriggerGuardExpressions
  */
 @SuppressWarnings("all")
 public class TriggerGuardExpressions {
+	
 	private TriggerGuardExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -36,38 +37,38 @@ public class TriggerGuardExpressions {
 	
 	@Test
 	public void trueGuard() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseE1();
 		statemachine.setB(true);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseE1();
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 	}
 	@Test
 	public void falseGuard() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.setB(false);
 		statemachine.raiseE1();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		statemachine.raiseE1();
 		statemachine.raiseE2();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/TypeAlias.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.typealias.TypeAliasStatemachine;
-import org.yakindu.scr.typealias.TypeAliasStatemachine.State;
+import org.yakindu.scr.typealias.TypeAliasStatemachine.State;	
 
 /**
  * Unit TestCase for TypeAlias
  */
 @SuppressWarnings("all")
 public class TypeAlias {
+	
 	private TypeAliasStatemachine statemachine;	
 	
 	@Before
@@ -36,16 +37,16 @@ public class TypeAlias {
 	
 	@Test
 	public void typeAliasTest() {
-		statemachine.enter();;
+		statemachine.enter();
 		assertTrue(statemachine.isStateActive(State.main_region_Start));
 		assertTrue(statemachine.getMyVar() == 1l);
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Mid));
 		assertTrue(statemachine.getMyString().equals("TypeSystem"));
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_Mid2));
 		statemachine.raiseMyEvent();
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.main_region_End));
 	}
 }

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/ValuedEvents.java

@@ -14,13 +14,14 @@ package org.yakindu.sct.generator.java.test;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.valuedevents.ValuedEventsStatemachine;
-import org.yakindu.scr.valuedevents.ValuedEventsStatemachine.State;
+import org.yakindu.scr.valuedevents.ValuedEventsStatemachine.State;	
 
 /**
  * Unit TestCase for ValuedEvents
  */
 @SuppressWarnings("all")
 public class ValuedEvents {
+	
 	private ValuedEventsStatemachine statemachine;	
 	
 	@Before
@@ -36,14 +37,14 @@ public class ValuedEvents {
 	
 	@Test
 	public void valuedEventsTest() {
-		statemachine.enter();;
-		statemachine.runCycle();;
+		statemachine.enter();
+		statemachine.runCycle();
 		assertTrue(statemachine.getMyString().equals("sct"));
 		statemachine.raiseIntegerEvent(23l);
 		statemachine.raiseBooleanEvent(false);
 		statemachine.raiseRealEvent(20l);
 		statemachine.raiseStringEvent("tool");
-		statemachine.runCycle();;
+		statemachine.runCycle();
 		assertTrue(statemachine.isStateActive(State.integer_region_D));
 		assertTrue(statemachine.isStateActive(State.string_region_D));
 		assertTrue(statemachine.isStateActive(State.boolean_region_D));