Newly generated the Testmodels for the Java Domain (#1471)

test-plugins/org.yakindu.sct.generator.java.test/pom.xml

@@ -21,7 +21,7 @@
 				<configuration>
 
 					<includes>
-						<include>**/AllTestsTest.class</include>
+						<include>**/AllTests.class</include>
 						<include>**/AllTestsTestCustom.class</include>
 					</includes>
 

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

@@ -0,0 +1,82 @@
+/**
+* Copyright (c) 2017 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+
+package org.yakindu.sct.generator.java.test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+	AlwaysOncycle.class,
+	AssignmentAsExpression.class,
+	BitExpressions.class,
+	BooleanExpressions.class,
+	CastExpressions.class,
+	Choice.class,
+	CKeywords.class,
+	ConditionalExpression.class,
+	ConstantsTests.class,
+	ConstOnlyDefaultScope.class,
+	ConstOnlyInternalScope.class,
+	ConstOnlyNamedScope.class,
+	Declarations.class,
+	DeepEntry.class,
+	DeepHistory.class,
+	DynamicChoice.class,
+	EmptyTransition.class,
+	EnterState.class,
+	EntryChoice.class,
+	EntryExitSelfTransition.class,
+	EntryReactionAction.class,
+	ExitOnSelfTransition.class,
+	ExitState.class,
+	FeatureCalls.class,
+	FinalState.class,
+	Guard.class,
+	GuardedEntry.class,
+	GuardedExit.class,
+	HistoryWithExitPoint.class,
+	HistoryWithoutInitialStep.class,
+	InEventLifeCycle.class,
+	IntegerExpressions.class,
+	InternalEventLifeCycle.class,
+	LocalReactions.class,
+	LogicalAndTests.class,
+	LogicalOrTests.class,
+	NamedInterfaceAccess.class,
+	OperationsTest.class,
+	OutEventLifeCycle.class,
+	Parenthesis.class,
+	PriorityValues.class,
+	RaiseEvent.class,
+	ReadOnlyVariable.class,
+	SameNameDifferentRegion.class,
+	ShallowHistory.class,
+	ShallowHistoryWithDeepEntry.class,
+	SimpleEvent.class,
+	SimpleHierachy.class,
+	StatechartActive.class,
+	StatechartLocalReactions.class,
+	StateIsActive.class,
+	StaticChoice.class,
+	STextKeywordsInStatesAndRegions.class,
+	StringExpressions.class,
+	SyncFork.class,
+	SyncJoin.class,
+	TransitionWithoutCondition.class,
+	TriggerGuardExpressions.class,
+	TriggerExpressionPrecedence.class,
+	ValuedEvents.class,
+	TypeAlias.class
+	})
+public class AllTests {
+}

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

@@ -1,82 +0,0 @@
-/**
-* Copyright (c) 2017 committers of YAKINDU and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*     committers of YAKINDU - initial API and implementation
-*/
-
-package org.yakindu.sct.generator.java.test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-import org.junit.runners.Suite.SuiteClasses;
-
-@RunWith(Suite.class)
-@SuiteClasses({
-	AlwaysOncycleTest.class,
-	AssignmentAsExpressionTest.class,
-	BitExpressionsTest.class,
-	BooleanExpressionsTest.class,
-	CastExpressionsTest.class,
-	ChoiceTest.class,
-	CKeywordsTest.class,
-	ConditionalExpressionTest.class,
-	ConstantsTestsTest.class,
-	ConstOnlyDefaultScopeTest.class,
-	ConstOnlyInternalScopeTest.class,
-	ConstOnlyNamedScopeTest.class,
-	DeclarationsTest.class,
-	DeepEntryTest.class,
-	DeepHistoryTest.class,
-	DynamicChoiceTest.class,
-	EmptyTransitionTest.class,
-	EnterStateTest.class,
-	EntryChoiceTest.class,
-	EntryExitSelfTransitionTest.class,
-	EntryReactionActionTest.class,
-	ExitOnSelfTransitionTest.class,
-	ExitStateTest.class,
-	FeatureCallsTest.class,
-	FinalStateTest.class,
-	GuardTest.class,
-	GuardedEntryTest.class,
-	GuardedExitTest.class,
-	HistoryWithExitPointTest.class,
-	HistoryWithoutInitialStepTest.class,
-	InEventLifeCycleTest.class,
-	IntegerExpressionsTest.class,
-	InternalEventLifeCycleTest.class,
-	LocalReactionsTest.class,
-	LogicalAndTestsTest.class,
-	LogicalOrTestsTest.class,
-	NamedInterfaceAccessTest.class,
-	OperationsTestTest.class,
-	OutEventLifeCycleTest.class,
-	ParenthesisTest.class,
-	PriorityValuesTest.class,
-	RaiseEventTest.class,
-	ReadOnlyVariableTest.class,
-	SameNameDifferentRegionTest.class,
-	ShallowHistoryTest.class,
-	ShallowHistoryWithDeepEntryTest.class,
-	SimpleEventTest.class,
-	SimpleHierachyTest.class,
-	StatechartActiveTest.class,
-	StatechartLocalReactionsTest.class,
-	StateIsActiveTest.class,
-	StaticChoiceTest.class,
-	STextKeywordsInStatesAndRegionsTest.class,
-	StringExpressionsTest.class,
-	SyncForkTest.class,
-	SyncJoinTest.class,
-	TransitionWithoutConditionTest.class,
-	TriggerGuardExpressionsTest.class,
-	TriggerExpressionPrecedenceTest.class,
-	ValuedEventsTest.class,
-	TypeAliasTest.class
-	})
-public class AllTestsTest {
-}

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

@@ -20,7 +20,7 @@ import org.yakindu.scr.alwaysoncycle.AlwaysOncycleStatemachine.State;
  * Unit TestCase for AlwaysOncycle
  */
 @SuppressWarnings("all")
-public class AlwaysOncycleTest {
+public class AlwaysOncycle {
 	private AlwaysOncycleStatemachine statemachine;	
 	
 	@Before
@@ -35,20 +35,20 @@ public class AlwaysOncycleTest {
 	}
 	
 	@Test
-	public void testAlwaysOncycleTest() {
-		statemachine.enter();
+	public void alwaysOnCycleTest() {
+		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/AssignmentAsExpressionTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.assignmentasexpression.AssignmentAsExpressionStatemachine
  * Unit TestCase for AssignmentAsExpression
  */
 @SuppressWarnings("all")
-public class AssignmentAsExpressionTest {
+public class AssignmentAsExpression {
 	private AssignmentAsExpressionStatemachine statemachine;	
 	
 	@Before
@@ -35,36 +35,36 @@ public class AssignmentAsExpressionTest {
 	}
 	
 	@Test
-	public void testSimpleAssignment() {
-		statemachine.enter();
+	public void simpleAssignment() {
+		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/BitExpressionsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.bitexpressions.BitExpressionsStatemachine.State;
  * Unit TestCase for BitExpressions
  */
 @SuppressWarnings("all")
-public class BitExpressionsTest {
+public class BitExpressions {
 	private BitExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -35,13 +35,13 @@ public class BitExpressionsTest {
 	}
 	
 	@Test
-	public void testBitExpressions() {
-		statemachine.enter();
+	public void bitExpressions() {
+		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/BooleanExpressionsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.booleanexpressions.BooleanExpressionsStatemachine.State;
  * Unit TestCase for BooleanExpressions
  */
 @SuppressWarnings("all")
-public class BooleanExpressionsTest {
+public class BooleanExpressions {
 	private BooleanExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -35,13 +35,13 @@ public class BooleanExpressionsTest {
 	}
 	
 	@Test
-	public void testBooleanExpressions() {
-		statemachine.enter();
+	public void booleanExpressions() {
+		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/CKeywordsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.ckeywords.CKeywordsStatemachine.State;
  * Unit TestCase for CKeywords
  */
 @SuppressWarnings("all")
-public class CKeywordsTest {
+public class CKeywords {
 	private CKeywordsStatemachine statemachine;	
 	
 	@Before
@@ -35,11 +35,11 @@ public class CKeywordsTest {
 	}
 	
 	@Test
-	public void testCKeywordsTest() {
-		statemachine.enter();
+	public void cKeywordsTest() {
+		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/CastExpressionsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.castexpressions.CastExpressionsStatemachine.State;
  * Unit TestCase for CastExpressions
  */
 @SuppressWarnings("all")
-public class CastExpressionsTest {
+public class CastExpressions {
 	private CastExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -35,13 +35,13 @@ public class CastExpressionsTest {
 	}
 	
 	@Test
-	public void testCastExpressionTest() {
-		statemachine.enter();
+	public void castExpressionTest() {
+		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/ChoiceTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.choice.ChoiceStatemachine.State;
  * Unit TestCase for Choice
  */
 @SuppressWarnings("all")
-public class ChoiceTest {
+public class Choice {
 	private ChoiceStatemachine statemachine;	
 	
 	@Before
@@ -35,66 +35,66 @@ public class ChoiceTest {
 	}
 	
 	@Test
-	public void testElseChoiceUsingNonDefaultTransition() {
+	public void elseChoiceUsingNonDefaultTransition() {
 		initForEventE(true);
 		assertTrue(statemachine.isStateActive(State.main_region_C));
 	}
 	@Test
-	public void testElseChoiceUsingDefaultTransition() {
+	public void elseChoiceUsingDefaultTransition() {
 		initForEventE(false);
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 	}
 	@Test
-	public void testDefaultChoiceUsingNonDefaultTransition() {
+	public void defaultChoiceUsingNonDefaultTransition() {
 		initForEventG(true);
 		assertTrue(statemachine.isStateActive(State.main_region_C));
 	}
 	@Test
-	public void testDefaultChoiceUsingDefaultTransition() {
+	public void defaultChoiceUsingDefaultTransition() {
 		initForEventG(false);
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 	}
 	@Test
-	public void testUncheckedChoiceUsingNonDefaultTransition() {
+	public void uncheckedChoiceUsingNonDefaultTransition() {
 		initForEventF(true);
 		assertTrue(statemachine.isStateActive(State.main_region_C));
 	}
 	@Test
-	public void testUncheckedChoiceUsingDefaultTransition() {
+	public void uncheckedChoiceUsingDefaultTransition() {
 		initForEventF(false);
 		assertTrue(statemachine.isStateActive(State.main_region_B));
 	}
 	@Test
-	public void testAlwaysTrueTransitionInChoice() {
+	public void alwaysTrueTransitionInChoice() {
 		initForEventH(true);
 		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/ConditionalExpressionTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.conditionalexpressions.ConditionalExpressionsStatemachine
  * Unit TestCase for ConditionalExpressions
  */
 @SuppressWarnings("all")
-public class ConditionalExpressionTest {
+public class ConditionalExpression {
 	private ConditionalExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -35,12 +35,12 @@ public class ConditionalExpressionTest {
 	}
 	
 	@Test
-	public void testConditionalExpressionTest() {
-		statemachine.enter();
+	public void conditionalExpressionTest() {
+		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/ConstOnlyDefaultScopeTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.constonlydefaultscope.ConstOnlyDefaultScopeStatemachine.S
  * Unit TestCase for ConstOnlyDefaultScope
  */
 @SuppressWarnings("all")
-public class ConstOnlyDefaultScopeTest {
+public class ConstOnlyDefaultScope {
 	private ConstOnlyDefaultScopeStatemachine statemachine;	
 	
 	@Before
@@ -35,15 +35,15 @@ public class ConstOnlyDefaultScopeTest {
 	}
 	
 	@Test
-	public void testStatechartEntry() {
-		statemachine.enter();
+	public void statechartEntry() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.constOnlyDefaultScope_main_region_A));
 	}
 	@Test
-	public void testStateTransition() {
-		statemachine.enter();
+	public void stateTransition() {
+		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/ConstOnlyInternalScopeTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.constonlyinternalscope.ConstOnlyInternalScopeStatemachine
  * Unit TestCase for ConstOnlyInternalScope
  */
 @SuppressWarnings("all")
-public class ConstOnlyInternalScopeTest {
+public class ConstOnlyInternalScope {
 	private ConstOnlyInternalScopeStatemachine statemachine;	
 	
 	@Before
@@ -35,15 +35,15 @@ public class ConstOnlyInternalScopeTest {
 	}
 	
 	@Test
-	public void testStatechartEntry() {
-		statemachine.enter();
+	public void statechartEntry() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.constOnlyInternalScope_main_region_A));
 	}
 	@Test
-	public void testStateTransition() {
-		statemachine.enter();
+	public void stateTransition() {
+		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/ConstOnlyNamedScopeTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.constonlynamedscope.ConstOnlyNamedScopeStatemachine.State
  * Unit TestCase for ConstOnlyNamedScope
  */
 @SuppressWarnings("all")
-public class ConstOnlyNamedScopeTest {
+public class ConstOnlyNamedScope {
 	private ConstOnlyNamedScopeStatemachine statemachine;	
 	
 	@Before
@@ -35,15 +35,15 @@ public class ConstOnlyNamedScopeTest {
 	}
 	
 	@Test
-	public void testStatechartEntry() {
-		statemachine.enter();
+	public void statechartEntry() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.constOnlyNamedScope_main_region_A));
 	}
 	@Test
-	public void testStateTransition() {
-		statemachine.enter();
+	public void stateTransition() {
+		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/ConstantsTestsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.constants.ConstantsStatemachine.State;
  * Unit TestCase for Constants
  */
 @SuppressWarnings("all")
-public class ConstantsTestsTest {
+public class ConstantsTests {
 	private ConstantsStatemachine statemachine;	
 	
 	@Before
@@ -35,21 +35,21 @@ public class ConstantsTestsTest {
 	}
 	
 	@Test
-	public void testConstantDefinition() {
-		statemachine.enter();
+	public void constantDefinition() {
+		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/DeclarationsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.declarations.DeclarationsStatemachine.State;
  * Unit TestCase for Declarations
  */
 @SuppressWarnings("all")
-public class DeclarationsTest {
+public class Declarations {
 	private DeclarationsStatemachine statemachine;	
 	
 	@Before
@@ -35,7 +35,7 @@ public class DeclarationsTest {
 	}
 	
 	@Test
-	public void testDeclarationsTest() {
-		statemachine.enter();
+	public void declarationsTest() {
+		statemachine.enter();;
 	}
 }

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

@@ -0,0 +1,44 @@
+/**
+* Copyright (c) 2017 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+
+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;
+
+/**
+ * Unit TestCase for DeepEntry
+ */
+@SuppressWarnings("all")
+public class DeepEntry {
+	private DeepEntryStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new DeepEntryStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void enterToSubstate() {
+		statemachine.enter();;
+		long vergleich = 4l;
+		assertTrue(vergleich == 4l);
+		statemachine.exit();;
+	}
+}

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

@@ -1,57 +0,0 @@
-/**
-* Copyright (c) 2017 committers of YAKINDU and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*     committers of YAKINDU - initial API and implementation
-*/
-
-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;
-
-/**
- * Unit TestCase for DeepEntry
- */
-@SuppressWarnings("all")
-public class DeepEntryTest {
-	private DeepEntryStatemachine statemachine;	
-	
-	@Before
-	public void setUp() {
-		statemachine = new DeepEntryStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-	
-	@Test
-	public void testEnterToSubstate() {
-		assertTrue(statemachine.getX() == 0l);
-		assertTrue(statemachine.getY() == 0l);
-		assertTrue(statemachine.getZ() == 0l);
-		statemachine.enter();
-		assertTrue(statemachine.getX() == 1l);
-		assertTrue(statemachine.getY() == 1l);
-		assertTrue(statemachine.getZ() == 2l);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r2_B_r_BB));
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r2_C));
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r2_B_r_BB));
-		assertTrue(statemachine.getY() == 1l);
-	}
-}

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

@@ -20,7 +20,7 @@ import org.yakindu.scr.deephistory.DeepHistoryStatemachine.State;
  * Unit TestCase for DeepHistory
  */
 @SuppressWarnings("all")
-public class DeepHistoryTest {
+public class DeepHistory {
 	private DeepHistoryStatemachine statemachine;	
 	
 	@Before
@@ -35,24 +35,24 @@ public class DeepHistoryTest {
 	}
 	
 	@Test
-	public void testDeepHistoryTest() {
-		statemachine.enter();
+	public void deepHistoryTest() {
+		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/DynamicChoiceTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.dynamicchoice.DynamicChoiceStatemachine.State;
  * Unit TestCase for DynamicChoice
  */
 @SuppressWarnings("all")
-public class DynamicChoiceTest {
+public class DynamicChoice {
 	private DynamicChoiceStatemachine statemachine;	
 	
 	@Before
@@ -35,10 +35,10 @@ public class DynamicChoiceTest {
 	}
 	
 	@Test
-	public void testDynamicChoiceTest() {
-		statemachine.enter();
+	public void dynamicChoiceTest() {
+		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/EmptyTransitionTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.emptytransition.EmptyTransitionStatemachine.State;
  * Unit TestCase for EmptyTransition
  */
 @SuppressWarnings("all")
-public class EmptyTransitionTest {
+public class EmptyTransition {
 	private EmptyTransitionStatemachine statemachine;	
 	
 	@Before
@@ -35,9 +35,9 @@ public class EmptyTransitionTest {
 	}
 	
 	@Test
-	public void testEmptyTransitionTest() {
-		statemachine.enter();
-		statemachine.runCycle();
+	public void emptyTransitionTest() {
+		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/EnterStateTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.enterstate.EnterStateStatemachine.State;
  * Unit TestCase for EnterState
  */
 @SuppressWarnings("all")
-public class EnterStateTest {
+public class EnterState {
 	private EnterStateStatemachine statemachine;	
 	
 	@Before
@@ -35,27 +35,27 @@ public class EnterStateTest {
 	}
 	
 	@Test
-	public void testDefaultEntry() {
-		statemachine.enter();
+	public void defaultEntry() {
+		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 testNamedEntryThroughNamedTransition() {
-		statemachine.enter();
+	public void namedEntryThroughNamedTransition() {
+		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 testNamedEntryThroughDefaultTransition() {
-		statemachine.enter();
+	public void namedEntryThroughDefaultTransition() {
+		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/EntryChoiceTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.entrychoice.EntryChoiceStatemachine.State;
  * Unit TestCase for EntryChoice
  */
 @SuppressWarnings("all")
-public class EntryChoiceTest {
+public class EntryChoice {
 	private EntryChoiceStatemachine statemachine;	
 	
 	@Before
@@ -35,10 +35,10 @@ public class EntryChoiceTest {
 	}
 	
 	@Test
-	public void testEntryChoiceTest() {
-		statemachine.enter();
-		statemachine.runCycle();
-		statemachine.runCycle();
+	public void entryChoiceTest() {
+		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/EntryExitSelfTransitionTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.entryexitselftransition.EntryExitSelfTransitionStatemachi
  * Unit TestCase for EntryExitSelfTransition
  */
 @SuppressWarnings("all")
-public class EntryExitSelfTransitionTest {
+public class EntryExitSelfTransition {
 	private EntryExitSelfTransitionStatemachine statemachine;	
 	
 	@Before
@@ -35,31 +35,33 @@ public class EntryExitSelfTransitionTest {
 	}
 	
 	@Test
-	public void testSelfTransitionToChildState() {
+	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();;
 	}
 	@Test
-	public void testSelfTransitionFromChildState() {
+	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();;
 	}
 	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/EntryReactionActionTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.entryreactionaction.EntryReactionActionStatemachine.State
  * Unit TestCase for EntryReactionAction
  */
 @SuppressWarnings("all")
-public class EntryReactionActionTest {
+public class EntryReactionAction {
 	private EntryReactionActionStatemachine statemachine;	
 	
 	@Before
@@ -35,39 +35,39 @@ public class EntryReactionActionTest {
 	}
 	
 	@Test
-	public void testEntryTransitionActionOnStatechartEnter() {
-		statemachine.enter();
+	public void entryTransitionActionOnStatechartEnter() {
+		statemachine.enter();;
 		assertTrue(statemachine.getEnteredR1());
 		assertTrue(statemachine.getEnteredR2());
 		assertTrue(statemachine.getEnteredBdefault());
 		assertTrue(!statemachine.getEnteredBother());
 	}
 	@Test
-	public void testEntryOnRTS() {
+	public void entryOnRTS() {
 		init();
 		statemachine.raiseB();
-		statemachine.runCycle();
+		statemachine.runCycle();;
 		assertTrue(!statemachine.getEnteredR1());
 		assertTrue(!statemachine.getEnteredR2());
 		assertTrue(!statemachine.getEnteredBdefault());
 		assertTrue(statemachine.getEnteredBother());
 	}
 	@Test
-	public void testNoEntryTransitionActionOnHistory() {
+	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/ExitOnSelfTransitionTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.exitonselftransition.ExitOnSelfTransitionStatemachine.Sta
  * Unit TestCase for ExitOnSelfTransition
  */
 @SuppressWarnings("all")
-public class ExitOnSelfTransitionTest {
+public class ExitOnSelfTransition {
 	private ExitOnSelfTransitionStatemachine statemachine;	
 	
 	@Before
@@ -35,17 +35,17 @@ public class ExitOnSelfTransitionTest {
 	}
 	
 	@Test
-	public void testExitOnSelfTransitionTest() {
-		statemachine.enter();
+	public void exitOnSelfTransitionTest() {
+		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/ExitStateTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.exitstate.ExitStateStatemachine.State;
  * Unit TestCase for ExitState
  */
 @SuppressWarnings("all")
-public class ExitStateTest {
+public class ExitState {
 	private ExitStateStatemachine statemachine;	
 	
 	@Before
@@ -35,34 +35,34 @@ public class ExitStateTest {
 	}
 	
 	@Test
-	public void testDefaultExit() {
-		statemachine.enter();
+	public void defaultExit() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.r_A));
 		statemachine.raiseE();
-		statemachine.runCycle();
+		statemachine.runCycle();;
 		assertTrue(statemachine.isStateActive(State.r_E));
 	}
 	@Test
-	public void testNamedExitThroughNamedTransition() {
-		statemachine.enter();
+	public void namedExitThroughNamedTransition() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.r_A));
 		statemachine.raiseF();
-		statemachine.runCycle();
+		statemachine.runCycle();;
 		assertTrue(statemachine.isStateActive(State.r_F));
 	}
 	@Test
-	public void testNamedExitThroughDefaultTransition() {
-		statemachine.enter();
+	public void namedExitThroughDefaultTransition() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.r_A));
 		statemachine.raiseG();
-		statemachine.runCycle();
+		statemachine.runCycle();;
 		assertTrue(statemachine.isStateActive(State.r_E));
 	}
 	@Test
-	public void testRemainInA() {
-		statemachine.enter();
+	public void remainInA() {
+		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/FeatureCallsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.featurecalls.FeatureCallsStatemachine.State;
  * Unit TestCase for FeatureCalls
  */
 @SuppressWarnings("all")
-public class FeatureCallsTest {
+public class FeatureCalls {
 	private FeatureCallsStatemachine statemachine;	
 	
 	@Before
@@ -35,10 +35,10 @@ public class FeatureCallsTest {
 	}
 	
 	@Test
-	public void testFeatureCalls() {
-		statemachine.enter();
+	public void featureCalls() {
+		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/FinalStateTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.finalstate.FinalStateStatemachine.State;
  * Unit TestCase for FinalState
  */
 @SuppressWarnings("all")
-public class FinalStateTest {
+public class FinalState {
 	private FinalStateStatemachine statemachine;	
 	
 	@Before
@@ -35,9 +35,9 @@ public class FinalStateTest {
 	}
 	
 	@Test
-	public void testStatechartNameTest() {
-		statemachine.enter();
-		statemachine.runCycle();
+	public void statechartNameTest() {
+		statemachine.enter();;
+		statemachine.runCycle();;
 		assertTrue(statemachine.isFinal());
 	}
 }

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

@@ -20,7 +20,7 @@ import org.yakindu.scr.guard.GuardStatemachine.State;
  * Unit TestCase for Guard
  */
 @SuppressWarnings("all")
-public class GuardTest {
+public class Guard {
 	private GuardStatemachine statemachine;	
 	
 	@Before
@@ -35,23 +35,23 @@ public class GuardTest {
 	}
 	
 	@Test
-	public void testGuardTest() {
-		statemachine.enter();
+	public void guardTest() {
+		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/GuardedEntryTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.guardedentry.GuardedEntryStatemachine.State;
  * Unit TestCase for GuardedEntry
  */
 @SuppressWarnings("all")
-public class GuardedEntryTest {
+public class GuardedEntry {
 	private GuardedEntryStatemachine statemachine;	
 	
 	@Before
@@ -35,39 +35,39 @@ public class GuardedEntryTest {
 	}
 	
 	@Test
-	public void testEntryNotTakenOnStatechartEnter() {
+	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 testEntryTakenOnStatechartEnter() {
+	public void entryTakenOnStatechartEnter() {
 		statemachine.setGuard(true);
-		statemachine.enter();
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		assertTrue(statemachine.getDone() == true);
 	}
 	@Test
-	public void testEntryTakenInTransition() {
+	public void entryTakenInTransition() {
 		initEntryInTransition(true,false);
 		assertTrue(statemachine.getDone());
 	}
 	@Test
-	public void testEntryNotTakenInTransition() {
+	public void entryNotTakenInTransition() {
 		initEntryInTransition(false,false);
 		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/GuardedExitTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.guardedexit.GuardedExitStatemachine.State;
  * Unit TestCase for GuardedExit
  */
 @SuppressWarnings("all")
-public class GuardedExitTest {
+public class GuardedExit {
 	private GuardedExitStatemachine statemachine;	
 	
 	@Before
@@ -35,22 +35,22 @@ public class GuardedExitTest {
 	}
 	
 	@Test
-	public void testExitTaken() {
-		statemachine.enter();
+	public void exitTaken() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.main_region_A));
 		assertTrue(!statemachine.getGuard());
 		checkDone(false);
 	}
 	@Test
-	public void testExitNotTaken() {
-		statemachine.enter();
+	public void exitNotTaken() {
+		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/HistoryWithExitPointTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.historywithexitpoint.HistoryWithExitPointStatemachine.Sta
  * Unit TestCase for HistoryWithExitPoint
  */
 @SuppressWarnings("all")
-public class HistoryWithExitPointTest {
+public class HistoryWithExitPoint {
 	private HistoryWithExitPointStatemachine statemachine;	
 	
 	@Before
@@ -35,23 +35,23 @@ public class HistoryWithExitPointTest {
 	}
 	
 	@Test
-	public void testHistoryEntryAfterExit() {
-		statemachine.enter();
+	public void historyEntryAfterExit() {
+		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/HistoryWithoutInitialStepTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.historywithoutinitialstep.HistoryWithoutInitialStepStatem
  * Unit TestCase for HistoryWithoutInitialStep
  */
 @SuppressWarnings("all")
-public class HistoryWithoutInitialStepTest {
+public class HistoryWithoutInitialStep {
 	private HistoryWithoutInitialStepStatemachine statemachine;	
 	
 	@Before
@@ -35,41 +35,41 @@ public class HistoryWithoutInitialStepTest {
 	}
 	
 	@Test
-	public void testEnterThroughInitialEntry() {
+	public void enterThroughInitialEntry() {
 		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
-	public void testEnterCThroughHistory() {
+	public void enterCThroughHistory() {
 		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 testEnterDThroughHistory() {
+	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/InEventLifeCycleTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.ineventlifecycle.InEventLifeCycleStatemachine.State;
  * Unit TestCase for InEventLifeCycle
  */
 @SuppressWarnings("all")
-public class InEventLifeCycleTest {
+public class InEventLifeCycle {
 	private InEventLifeCycleStatemachine statemachine;	
 	
 	@Before
@@ -35,11 +35,11 @@ public class InEventLifeCycleTest {
 	}
 	
 	@Test
-	public void testEventLifeCycle() {
-		statemachine.enter();
+	public void eventLifeCycle() {
+		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/IntegerExpressionsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.integerexpressions.IntegerExpressionsStatemachine.State;
  * Unit TestCase for IntegerExpressions
  */
 @SuppressWarnings("all")
-public class IntegerExpressionsTest {
+public class IntegerExpressions {
 	private IntegerExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -35,13 +35,13 @@ public class IntegerExpressionsTest {
 	}
 	
 	@Test
-	public void testIntegerExpressions() {
-		statemachine.enter();
+	public void integerExpressions() {
+		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/InternalEventLifeCycleTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.internaleventlifecycle.InternalEventLifeCycleStatemachine
  * Unit TestCase for InternalEventLifeCycle
  */
 @SuppressWarnings("all")
-public class InternalEventLifeCycleTest {
+public class InternalEventLifeCycle {
 	private InternalEventLifeCycleStatemachine statemachine;	
 	
 	@Before
@@ -35,22 +35,22 @@ public class InternalEventLifeCycleTest {
 	}
 	
 	@Test
-	public void testInternalEventLifeCycleTest() {
-		statemachine.enter();
+	public void internalEventLifeCycleTest() {
+		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/LocalReactionsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.localreactions.LocalReactionsStatemachine.State;
  * Unit TestCase for LocalReactions
  */
 @SuppressWarnings("all")
-public class LocalReactionsTest {
+public class LocalReactions {
 	private LocalReactionsStatemachine statemachine;	
 	
 	@Before
@@ -35,10 +35,10 @@ public class LocalReactionsTest {
 	}
 	
 	@Test
-	public void testLocalReactionsTest() {
-		statemachine.enter();
+	public void localReactionsTest() {
+		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/LogicalAndTestsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.logicaland.LogicalAndStatemachine.State;
  * Unit TestCase for LogicalAnd
  */
 @SuppressWarnings("all")
-public class LogicalAndTestsTest {
+public class LogicalAndTests {
 	private LogicalAndStatemachine statemachine;	
 	
 	@Before
@@ -35,9 +35,9 @@ public class LogicalAndTestsTest {
 	}
 	
 	@Test
-	public void testOperandEvaluationOrder() {
-		statemachine.enter();
-		statemachine.runCycle();
+	public void operandEvaluationOrder() {
+		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/LogicalOrTestsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.logicalor.LogicalOrStatemachine.State;
  * Unit TestCase for LogicalOr
  */
 @SuppressWarnings("all")
-public class LogicalOrTestsTest {
+public class LogicalOrTests {
 	private LogicalOrStatemachine statemachine;	
 	
 	@Before
@@ -35,9 +35,9 @@ public class LogicalOrTestsTest {
 	}
 	
 	@Test
-	public void testOperandEvaluationOrder() {
-		statemachine.enter();
-		statemachine.runCycle();
+	public void operandEvaluationOrder() {
+		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/NamedInterfaceAccessTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.namedinterfaceaccess.NamedInterfaceAccessStatemachine.Sta
  * Unit TestCase for NamedInterfaceAccess
  */
 @SuppressWarnings("all")
-public class NamedInterfaceAccessTest {
+public class NamedInterfaceAccess {
 	private NamedInterfaceAccessStatemachine statemachine;	
 	
 	@Before
@@ -35,15 +35,15 @@ public class NamedInterfaceAccessTest {
 	}
 	
 	@Test
-	public void testSafeOpenSuccess() {
-		statemachine.enter();
-		statemachine.runCycle();
+	public void safeOpenSuccess() {
+		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/NullCheckTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.nullcheck.NullCheckStatemachine.State;
  * Unit TestCase for NullCheck
  */
 @SuppressWarnings("all")
-public class NullCheckTest {
+public class NullCheck {
 	private NullCheckStatemachine statemachine;	
 	
 	@Before
@@ -35,10 +35,10 @@ public class NullCheckTest {
 	}
 	
 	@Test
-	public void testSimpleNullCheckTest() {
-		statemachine.enter();
+	public void simpleNullCheckTest() {
+		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

@@ -17,8 +17,6 @@ import static org.hamcrest.CoreMatchers.*;
 import org.yakindu.scr.operations.IOperationsStatemachine.*;
 import org.mockito.ArgumentCaptor;
 import static org.mockito.ArgumentCaptor.forClass;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.operations.OperationsStatemachine;
@@ -55,106 +53,87 @@ public class OperationsTest {
 	}
 	
 	@Test
-	public void testOperationsCalled() {
+	public void operationsCalled() {
 		when(defaultMock.alwaysTrue()).thenReturn(true);
 		 
-		when(internalMock.internalOperation3a(anyDouble())).thenAnswer(new Answer<Double>() {
-			@Override
-			public Double answer(InvocationOnMock invocation) {
-				Object[] args = invocation.getArguments();
-				Double param1 = (Double) args[0];
-				return param1+1.0;
-			}
-		});
-		 
-		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();
 		 
-		ArgumentCaptor<Long> longCaptureinternalOperation2_7_0 = forClass(Long.class);
-		verify(internalMock, atLeastOnce()).internalOperation2(longCaptureinternalOperation2_7_0.capture());
-		assertThat(longCaptureinternalOperation2_7_0.getValue(), is(4l));
+		ArgumentCaptor<Long> longCaptureinternalOperation2_6_0 = forClass(Long.class);
+		verify(internalMock, atLeastOnce()).internalOperation2(longCaptureinternalOperation2_6_0.capture());
+		assertThat(longCaptureinternalOperation2_6_0.getValue(), is(4l));
 		 
 		verify(internalMock, atLeastOnce()).internalOperation3();
 		 
-		ArgumentCaptor<Double> doubleCaptureinternalOperation3a_9_0 = forClass(Double.class);
-		verify(internalMock, atLeastOnce()).internalOperation3a(doubleCaptureinternalOperation3a_9_0.capture());
+		ArgumentCaptor<Double> doubleCaptureinternalOperation3a_8_0 = forClass(Double.class);
+		verify(internalMock, atLeastOnce()).internalOperation3a(doubleCaptureinternalOperation3a_8_0.capture());
+		assertThat(doubleCaptureinternalOperation3a_8_0.getValue(), is(1.0));
 		 
 		verify(internalMock, atLeastOnce()).internalOperation4();
 		 
-		ArgumentCaptor<Long> longCaptureinternalOperation4a_11_0 = forClass(Long.class);
-		verify(internalMock, atLeastOnce()).internalOperation4a(longCaptureinternalOperation4a_11_0.capture());
-		assertThat(longCaptureinternalOperation4a_11_0.getValue(), is(5l));
+		ArgumentCaptor<Long> longCaptureinternalOperation4a_10_0 = forClass(Long.class);
+		verify(internalMock, atLeastOnce()).internalOperation4a(longCaptureinternalOperation4a_10_0.capture());
+		assertThat(longCaptureinternalOperation4a_10_0.getValue(), is(5l));
 		 
 		verify(internalMock, atLeastOnce()).internalOperation5();
 		 
-		ArgumentCaptor<String> stringCaptureinternalOperation5a_13_0 = forClass(String.class);
-		verify(internalMock, atLeastOnce()).internalOperation5a(stringCaptureinternalOperation5a_13_0.capture());
-		assertThat(stringCaptureinternalOperation5a_13_0.getValue(), is(""));
+		ArgumentCaptor<String> stringCaptureinternalOperation5a_12_0 = forClass(String.class);
+		verify(internalMock, atLeastOnce()).internalOperation5a(stringCaptureinternalOperation5a_12_0.capture());
 		 
-		ArgumentCaptor<Long> longCaptureinternalOperation2_14_0 = forClass(Long.class);
-		verify(internalMock, atLeastOnce()).internalOperation2(longCaptureinternalOperation2_14_0.capture());
-		assertThat(longCaptureinternalOperation2_14_0.getValue(), is(4l));
-		 
-		statemachine.raiseEv();;
-		statemachine.runCycle();
+		statemachine.raiseEv();
+		statemachine.runCycle();;
 		assertTrue(statemachine.isStateActive(State.main_region_C));
-		 
 		verify(interface1Mock, atLeastOnce()).interfaceOperation1();
 		 
-		ArgumentCaptor<Long> longCaptureinterfaceOperation2_19_0 = forClass(Long.class);
-		verify(interface1Mock, atLeastOnce()).interfaceOperation2(longCaptureinterfaceOperation2_19_0.capture());
-		assertThat(longCaptureinterfaceOperation2_19_0.getValue(), is(4l));
+		ArgumentCaptor<Long> longCaptureinterfaceOperation2_17_0 = forClass(Long.class);
+		verify(interface1Mock, atLeastOnce()).interfaceOperation2(longCaptureinterfaceOperation2_17_0.capture());
+		assertThat(longCaptureinterfaceOperation2_17_0.getValue(), is(4l));
 		 
 		verify(interface1Mock, atLeastOnce()).interfaceOperation3();
 		 
-		ArgumentCaptor<Double> doubleCaptureinterfaceOperation3a_21_0 = forClass(Double.class);
-		verify(interface1Mock, atLeastOnce()).interfaceOperation3a(doubleCaptureinterfaceOperation3a_21_0.capture());
-		assertThat(doubleCaptureinterfaceOperation3a_21_0.getValue(), is(1.0));
+		ArgumentCaptor<Double> doubleCaptureinterfaceOperation3a_19_0 = forClass(Double.class);
+		verify(interface1Mock, atLeastOnce()).interfaceOperation3a(doubleCaptureinterfaceOperation3a_19_0.capture());
+		assertThat(doubleCaptureinterfaceOperation3a_19_0.getValue(), is(1.0));
 		 
 		verify(interface1Mock, atLeastOnce()).interfaceOperation4();
 		 
-		ArgumentCaptor<Long> longCaptureinterfaceOperation4a_23_0 = forClass(Long.class);
-		verify(interface1Mock, atLeastOnce()).interfaceOperation4a(longCaptureinterfaceOperation4a_23_0.capture());
-		assertThat(longCaptureinterfaceOperation4a_23_0.getValue(), is(5l));
+		ArgumentCaptor<Long> longCaptureinterfaceOperation4a_21_0 = forClass(Long.class);
+		verify(interface1Mock, atLeastOnce()).interfaceOperation4a(longCaptureinterfaceOperation4a_21_0.capture());
+		assertThat(longCaptureinterfaceOperation4a_21_0.getValue(), is(5l));
 		 
 		verify(interface1Mock, atLeastOnce()).interfaceOperation5();
 		 
-		ArgumentCaptor<String> stringCaptureinterfaceOperation5a_25_0 = forClass(String.class);
-		verify(interface1Mock, atLeastOnce()).interfaceOperation5a(stringCaptureinterfaceOperation5a_25_0.capture());
-		assertThat(stringCaptureinterfaceOperation5a_25_0.getValue(), is(""));
+		ArgumentCaptor<String> stringCaptureinterfaceOperation5a_23_0 = forClass(String.class);
+		verify(interface1Mock, atLeastOnce()).interfaceOperation5a(stringCaptureinterfaceOperation5a_23_0.capture());
 		 
-		statemachine.raiseEv();;
-		statemachine.runCycle();
+		statemachine.raiseEv();
+		statemachine.runCycle();;
 		assertTrue(statemachine.isStateActive(State.main_region_D));
-		 
 		verify(defaultMock, atLeastOnce()).unnamedInterfaceOperation1();
 		 
-		ArgumentCaptor<Long> longCaptureunnamedInterfaceOperation2_30_0 = forClass(Long.class);
-		verify(defaultMock, atLeastOnce()).unnamedInterfaceOperation2(longCaptureunnamedInterfaceOperation2_30_0.capture());
-		assertThat(longCaptureunnamedInterfaceOperation2_30_0.getValue(), is(4l));
+		ArgumentCaptor<Long> longCaptureunnamedInterfaceOperation2_28_0 = forClass(Long.class);
+		verify(defaultMock, atLeastOnce()).unnamedInterfaceOperation2(longCaptureunnamedInterfaceOperation2_28_0.capture());
+		assertThat(longCaptureunnamedInterfaceOperation2_28_0.getValue(), is(4l));
 		 
 		verify(defaultMock, atLeastOnce()).unnamedOperation3();
 		 
-		ArgumentCaptor<Double> doubleCaptureunnamedOperation3a_32_0 = forClass(Double.class);
-		verify(defaultMock, atLeastOnce()).unnamedOperation3a(doubleCaptureunnamedOperation3a_32_0.capture());
-		assertThat(doubleCaptureunnamedOperation3a_32_0.getValue(), is(1.0));
+		ArgumentCaptor<Double> doubleCaptureunnamedOperation3a_30_0 = forClass(Double.class);
+		verify(defaultMock, atLeastOnce()).unnamedOperation3a(doubleCaptureunnamedOperation3a_30_0.capture());
+		assertThat(doubleCaptureunnamedOperation3a_30_0.getValue(), is(1.0));
 		 
 		verify(defaultMock, atLeastOnce()).unnamedOperation4();
 		 
-		ArgumentCaptor<Long> longCaptureunnamedOperation4a_34_0 = forClass(Long.class);
-		verify(defaultMock, atLeastOnce()).unnamedOperation4a(longCaptureunnamedOperation4a_34_0.capture());
-		assertThat(longCaptureunnamedOperation4a_34_0.getValue(), is(5l));
+		ArgumentCaptor<Long> longCaptureunnamedOperation4a_32_0 = forClass(Long.class);
+		verify(defaultMock, atLeastOnce()).unnamedOperation4a(longCaptureunnamedOperation4a_32_0.capture());
+		assertThat(longCaptureunnamedOperation4a_32_0.getValue(), is(5l));
 		 
 		verify(defaultMock, atLeastOnce()).unnamedOperation5();
 		 
-		ArgumentCaptor<String> stringCaptureunnamedOperation5a_36_0 = forClass(String.class);
-		verify(defaultMock, atLeastOnce()).unnamedOperation5a(stringCaptureunnamedOperation5a_36_0.capture());
-		assertThat(stringCaptureunnamedOperation5a_36_0.getValue(), is(""));
+		ArgumentCaptor<String> stringCaptureunnamedOperation5a_34_0 = forClass(String.class);
+		verify(defaultMock, atLeastOnce()).unnamedOperation5a(stringCaptureunnamedOperation5a_34_0.capture());
 		 
 	}
 }

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

@@ -1,139 +0,0 @@
-/**
-* Copyright (c) 2017 committers of YAKINDU and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*     committers of YAKINDU - initial API and implementation
-*/
-
-package org.yakindu.sct.generator.java.test;
-
-import static org.mockito.Mockito.*;
-import static org.mockito.Matchers.*;
-import static org.hamcrest.CoreMatchers.*;
-import org.yakindu.scr.operations.IOperationsStatemachine.*;
-import org.mockito.ArgumentCaptor;
-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;
-
-/**
- * Unit TestCase for Operations
- */
-@SuppressWarnings("all")
-public class OperationsTestTest {
-	SCInterfaceOperationCallback defaultMock;
-	InternalOperationCallback internalMock;
-	SCIInterface1OperationCallback interface1Mock;
-	private OperationsStatemachine statemachine;	
-	
-	@Before
-	public void setUp() {
-		statemachine = new OperationsStatemachine();
-		statemachine.init();
-		defaultMock = mock(SCInterfaceOperationCallback.class);
-		statemachine.getSCInterface().setSCInterfaceOperationCallback(defaultMock);
-		internalMock = mock(InternalOperationCallback.class);
-		statemachine.setInternalOperationCallback(internalMock);
-		interface1Mock = mock(SCIInterface1OperationCallback.class);
-		statemachine.getSCIInterface1().setSCIInterface1OperationCallback(interface1Mock);
-	}
-
-	@After
-	public void tearDown() {
-		statemachine.getSCInterface().setSCInterfaceOperationCallback(null);
-		statemachine.setInternalOperationCallback(null);
-		statemachine.getSCIInterface1().setSCIInterface1OperationCallback(null);
-		statemachine = null;
-	}
-	
-	@Test
-	public void testOperationsCalled() {
-		when(defaultMock.alwaysTrue()).thenReturn(true);
-		 
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		verify(internalMock, atLeastOnce()).internalOperation1();
-		 
-		ArgumentCaptor<Long> longCaptureinternalOperation2_6_0 = forClass(Long.class);
-		verify(internalMock, atLeastOnce()).internalOperation2(longCaptureinternalOperation2_6_0.capture());
-		assertThat(longCaptureinternalOperation2_6_0.getValue(), is(4l));
-		 
-		verify(internalMock, atLeastOnce()).internalOperation3();
-		 
-		ArgumentCaptor<Double> doubleCaptureinternalOperation3a_8_0 = forClass(Double.class);
-		verify(internalMock, atLeastOnce()).internalOperation3a(doubleCaptureinternalOperation3a_8_0.capture());
-		assertThat(doubleCaptureinternalOperation3a_8_0.getValue(), is(1.0));
-		 
-		verify(internalMock, atLeastOnce()).internalOperation4();
-		 
-		ArgumentCaptor<Long> longCaptureinternalOperation4a_10_0 = forClass(Long.class);
-		verify(internalMock, atLeastOnce()).internalOperation4a(longCaptureinternalOperation4a_10_0.capture());
-		assertThat(longCaptureinternalOperation4a_10_0.getValue(), is(5l));
-		 
-		verify(internalMock, atLeastOnce()).internalOperation5();
-		 
-		ArgumentCaptor<String> stringCaptureinternalOperation5a_12_0 = forClass(String.class);
-		verify(internalMock, atLeastOnce()).internalOperation5a(stringCaptureinternalOperation5a_12_0.capture());
-		 
-		statemachine.raiseEv();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_C));
-		verify(interface1Mock, atLeastOnce()).interfaceOperation1();
-		 
-		ArgumentCaptor<Long> longCaptureinterfaceOperation2_17_0 = forClass(Long.class);
-		verify(interface1Mock, atLeastOnce()).interfaceOperation2(longCaptureinterfaceOperation2_17_0.capture());
-		assertThat(longCaptureinterfaceOperation2_17_0.getValue(), is(4l));
-		 
-		verify(interface1Mock, atLeastOnce()).interfaceOperation3();
-		 
-		ArgumentCaptor<Double> doubleCaptureinterfaceOperation3a_19_0 = forClass(Double.class);
-		verify(interface1Mock, atLeastOnce()).interfaceOperation3a(doubleCaptureinterfaceOperation3a_19_0.capture());
-		assertThat(doubleCaptureinterfaceOperation3a_19_0.getValue(), is(1.0));
-		 
-		verify(interface1Mock, atLeastOnce()).interfaceOperation4();
-		 
-		ArgumentCaptor<Long> longCaptureinterfaceOperation4a_21_0 = forClass(Long.class);
-		verify(interface1Mock, atLeastOnce()).interfaceOperation4a(longCaptureinterfaceOperation4a_21_0.capture());
-		assertThat(longCaptureinterfaceOperation4a_21_0.getValue(), is(5l));
-		 
-		verify(interface1Mock, atLeastOnce()).interfaceOperation5();
-		 
-		ArgumentCaptor<String> stringCaptureinterfaceOperation5a_23_0 = forClass(String.class);
-		verify(interface1Mock, atLeastOnce()).interfaceOperation5a(stringCaptureinterfaceOperation5a_23_0.capture());
-		 
-		statemachine.raiseEv();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_D));
-		verify(defaultMock, atLeastOnce()).unnamedInterfaceOperation1();
-		 
-		ArgumentCaptor<Long> longCaptureunnamedInterfaceOperation2_28_0 = forClass(Long.class);
-		verify(defaultMock, atLeastOnce()).unnamedInterfaceOperation2(longCaptureunnamedInterfaceOperation2_28_0.capture());
-		assertThat(longCaptureunnamedInterfaceOperation2_28_0.getValue(), is(4l));
-		 
-		verify(defaultMock, atLeastOnce()).unnamedOperation3();
-		 
-		ArgumentCaptor<Double> doubleCaptureunnamedOperation3a_30_0 = forClass(Double.class);
-		verify(defaultMock, atLeastOnce()).unnamedOperation3a(doubleCaptureunnamedOperation3a_30_0.capture());
-		assertThat(doubleCaptureunnamedOperation3a_30_0.getValue(), is(1.0));
-		 
-		verify(defaultMock, atLeastOnce()).unnamedOperation4();
-		 
-		ArgumentCaptor<Long> longCaptureunnamedOperation4a_32_0 = forClass(Long.class);
-		verify(defaultMock, atLeastOnce()).unnamedOperation4a(longCaptureunnamedOperation4a_32_0.capture());
-		assertThat(longCaptureunnamedOperation4a_32_0.getValue(), is(5l));
-		 
-		verify(defaultMock, atLeastOnce()).unnamedOperation5();
-		 
-		ArgumentCaptor<String> stringCaptureunnamedOperation5a_34_0 = forClass(String.class);
-		verify(defaultMock, atLeastOnce()).unnamedOperation5a(stringCaptureunnamedOperation5a_34_0.capture());
-		 
-	}
-}

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

@@ -11,6 +11,12 @@
 
 package org.yakindu.sct.generator.java.test;
 
+import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.*;
+import static org.hamcrest.CoreMatchers.*;
+import org.yakindu.scr.operationswithoutbraces.IOperationsWithoutBracesStatemachine.*;
+import org.mockito.ArgumentCaptor;
+import static org.mockito.ArgumentCaptor.forClass;
 import org.junit.*;
 import static org.junit.Assert.*;
 import org.yakindu.scr.operationswithoutbraces.OperationsWithoutBracesStatemachine;
@@ -20,32 +26,39 @@ import org.yakindu.scr.operationswithoutbraces.OperationsWithoutBracesStatemachi
  * Unit TestCase for OperationsWithoutBraces
  */
 @SuppressWarnings("all")
-public class OperationsWithoutBracesTest {
+public class OperationsWithoutBraces {
+	SCInterfaceOperationCallback defaultMock;
 	private OperationsWithoutBracesStatemachine statemachine;	
 	
 	@Before
 	public void setUp() {
 		statemachine = new OperationsWithoutBracesStatemachine();
 		statemachine.init();
+		defaultMock = mock(SCInterfaceOperationCallback.class);
+		statemachine.getSCInterface().setSCInterfaceOperationCallback(defaultMock);
 	}
 
 	@After
 	public void tearDown() {
+		statemachine.getSCInterface().setSCInterfaceOperationCallback(null);
 		statemachine = null;
 	}
 	
 	@Test
-	public void testOperationsWithoutBracesTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
+	public void operationsWithoutBracesTest() {
+		when(defaultMock.myBoolOp()).thenReturn(false);
+		 
+		when(defaultMock.myIntOp()).thenReturn(0l);
+		 
+		when(defaultMock.myRealOp()).thenReturn(0.0);
+		 
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.another_region_A));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		assertTrue(statemachine.isStateActive(State.another_region_B));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_C));
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		statemachine.runCycle();;
 		assertTrue(statemachine.isStateActive(State.another_region_C));
-		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_C));
+		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/OutEventLifeCycleTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.outeventlifecycle.OutEventLifeCycleStatemachine.State;
  * Unit TestCase for OutEventLifeCycle
  */
 @SuppressWarnings("all")
-public class OutEventLifeCycleTest {
+public class OutEventLifeCycle {
 	private OutEventLifeCycleStatemachine statemachine;	
 	
 	@Before
@@ -35,33 +35,33 @@ public class OutEventLifeCycleTest {
 	}
 	
 	@Test
-	public void testAvailableAfterCycle() {
-		statemachine.enter();
+	public void availableAfterCycle() {
+		statemachine.enter();;
 		statemachine.raiseE();
-		statemachine.runCycle();
+		statemachine.runCycle();;
 		assertTrue(statemachine.isRaisedF());
 	}
 	@Test
-	public void testAvailableWithinCycle() {
+	public void availableWithinCycle() {
 		init(false);
 		assertTrue(statemachine.getF_available_in_cycle());
 	}
 	@Test
-	public void testUnvailableWithin2ndCycle() {
+	public void unvailableWithin2ndCycle() {
 		init(true);
 		assertTrue(!statemachine.getF_available_in_next_cycle());
 	}
 	@Test
-	public void testUnvailableAfter2ndCycle() {
+	public void unvailableAfter2ndCycle() {
 		init(true);
 		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/ParenthesisTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.parenthesis.ParenthesisStatemachine.State;
  * Unit TestCase for Parenthesis
  */
 @SuppressWarnings("all")
-public class ParenthesisTest {
+public class Parenthesis {
 	private ParenthesisStatemachine statemachine;	
 	
 	@Before
@@ -35,8 +35,8 @@ public class ParenthesisTest {
 	}
 	
 	@Test
-	public void testSimple() {
-		statemachine.enter();
+	public void simple() {
+		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/PerformanceTestsTest.java

@@ -21,7 +21,7 @@ import org.yakindu.scr.TimerService;
  * Unit TestCase for PerformanceTest
  */
 @SuppressWarnings("all")
-public class PerformanceTestsTest {
+public class PerformanceTests {
 	private PerformanceTestStatemachine statemachine;	
 	
 	@Before
@@ -37,19 +37,19 @@ public class PerformanceTestsTest {
 	}
 	
 	@Test
-	public void testTest_100_000() {
+	public void test_100_000() {
 		performance(100000l);
 	}
 	@Test
-	public void testTest_1_000_000() {
+	public void test_1_000_000() {
 		performance(1000000l);
 	}
 	@Test
-	public void testTest_10_000_000() {
+	public void test_10_000_000() {
 		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 +63,7 @@ public class PerformanceTestsTest {
 					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/PriorityValuesTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.priorityvalues.PriorityValuesStatemachine.State;
  * Unit TestCase for PriorityValues
  */
 @SuppressWarnings("all")
-public class PriorityValuesTest {
+public class PriorityValues {
 	private PriorityValuesStatemachine statemachine;	
 	
 	@Before
@@ -35,19 +35,19 @@ public class PriorityValuesTest {
 	}
 	
 	@Test
-	public void testTransitionPriority() {
-		statemachine.enter();
+	public void transitionPriority() {
+		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 testRegionPriority() {
-		statemachine.enter();
+	public void regionPriority() {
+		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/RaiseEventTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.raiseevent.RaiseEventStatemachine.State;
  * Unit TestCase for RaiseEvent
  */
 @SuppressWarnings("all")
-public class RaiseEventTest {
+public class RaiseEvent {
 	private RaiseEventStatemachine statemachine;	
 	
 	@Before
@@ -35,13 +35,13 @@ public class RaiseEventTest {
 	}
 	
 	@Test
-	public void testRaiseEvent() {
-		statemachine.enter();
+	public void raiseEvent() {
+		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/ReadOnlyVariableTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.readonlyvariable.ReadOnlyVariableStatemachine.State;
  * Unit TestCase for ReadOnlyVariable
  */
 @SuppressWarnings("all")
-public class ReadOnlyVariableTest {
+public class ReadOnlyVariable {
 	private ReadOnlyVariableStatemachine statemachine;	
 	
 	@Before
@@ -35,8 +35,8 @@ public class ReadOnlyVariableTest {
 	}
 	
 	@Test
-	public void testReadOnlyVariableTest() {
-		statemachine.enter();
+	public void readOnlyVariableTest() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.main_region_StateA));
 		assertTrue(statemachine.getMyInt() == 0l);
 		assertTrue(statemachine.getMyString().equals("testString"));
@@ -46,7 +46,7 @@ public class ReadOnlyVariableTest {
 		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/STextKeywordsInStatesAndRegionsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.stextkeywordsinstatesandregions.STextKeywordsInStatesAndR
  * Unit TestCase for STextKeywordsInStatesAndRegions
  */
 @SuppressWarnings("all")
-public class STextKeywordsInStatesAndRegionsTest {
+public class STextKeywordsInStatesAndRegions {
 	private STextKeywordsInStatesAndRegionsStatemachine statemachine;	
 	
 	@Before
@@ -35,8 +35,8 @@ public class STextKeywordsInStatesAndRegionsTest {
 	}
 	
 	@Test
-	public void testActiveCheckWithSTextNamedStates() {
-		statemachine.enter();
+	public void activeCheckWithSTextNamedStates() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.default_namespace));
 		assertTrue(statemachine.isStateActive(State.operation_interface));
 		assertTrue(statemachine.isStateActive(State.namespace_event));
@@ -58,7 +58,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +80,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +102,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +124,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +146,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +168,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +190,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +212,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +234,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +256,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +278,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +300,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +322,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +344,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +366,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +388,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +410,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +432,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +454,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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 +476,7 @@ public class STextKeywordsInStatesAndRegionsTest {
 		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/SameNameDifferentRegionTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.samenamedifferentregion.SameNameDifferentRegionStatemachi
  * Unit TestCase for SameNameDifferentRegion
  */
 @SuppressWarnings("all")
-public class SameNameDifferentRegionTest {
+public class SameNameDifferentRegion {
 	private SameNameDifferentRegionStatemachine statemachine;	
 	
 	@Before
@@ -35,15 +35,15 @@ public class SameNameDifferentRegionTest {
 	}
 	
 	@Test
-	public void testSameNameDifferenRegionTest() {
-		statemachine.enter();
+	public void sameNameDifferenRegionTest() {
+		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/ShallowHistoryTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.shallowhistory.ShallowHistoryStatemachine.State;
  * Unit TestCase for ShallowHistory
  */
 @SuppressWarnings("all")
-public class ShallowHistoryTest {
+public class ShallowHistory {
 	private ShallowHistoryStatemachine statemachine;	
 	
 	@Before
@@ -35,36 +35,36 @@ public class ShallowHistoryTest {
 	}
 	
 	@Test
-	public void testShallowHistoryTest() {
-		statemachine.enter();
+	public void shallowHistoryTest() {
+		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/ShallowHistoryWithDeepEntryTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.shallowhistorywithdeepentry.ShallowHistoryWithDeepEntrySt
  * Unit TestCase for ShallowHistoryWithDeepEntry
  */
 @SuppressWarnings("all")
-public class ShallowHistoryWithDeepEntryTest {
+public class ShallowHistoryWithDeepEntry {
 	private ShallowHistoryWithDeepEntryStatemachine statemachine;	
 	
 	@Before
@@ -35,51 +35,51 @@ public class ShallowHistoryWithDeepEntryTest {
 	}
 	
 	@Test
-	public void testNoDeepEntryWithinHistory() {
-		statemachine.enter();
+	public void noDeepEntryWithinHistory() {
+		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 testDeepEntryWithinHistory() {
-		statemachine.enter();
+	public void deepEntryWithinHistory() {
+		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 testDirectDeepEntryIntoHistory() {
-		statemachine.enter();
+	public void directDeepEntryIntoHistory() {
+		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/SimpleEventTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.simpleevent.SimpleEventStatemachine.State;
  * Unit TestCase for SimpleEvent
  */
 @SuppressWarnings("all")
-public class SimpleEventTest {
+public class SimpleEvent {
 	private SimpleEventStatemachine statemachine;	
 	
 	@Before
@@ -35,14 +35,14 @@ public class SimpleEventTest {
 	}
 	
 	@Test
-	public void testSimpleEventTest() {
-		statemachine.enter();
+	public void simpleEventTest() {
+		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/SimpleHierachyTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.simplehierachy.SimpleHierachyStatemachine.State;
  * Unit TestCase for SimpleHierachy
  */
 @SuppressWarnings("all")
-public class SimpleHierachyTest {
+public class SimpleHierachy {
 	private SimpleHierachyStatemachine statemachine;	
 	
 	@Before
@@ -35,13 +35,13 @@ public class SimpleHierachyTest {
 	}
 	
 	@Test
-	public void testSimpleHierachyTest() {
-		statemachine.enter();
+	public void simpleHierachyTest() {
+		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/StateIsActiveTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.stateisactive.StateIsActiveStatemachine.State;
  * Unit TestCase for StateIsActive
  */
 @SuppressWarnings("all")
-public class StateIsActiveTest {
+public class StateIsActive {
 	private StateIsActiveStatemachine statemachine;	
 	
 	@Before
@@ -35,13 +35,13 @@ public class StateIsActiveTest {
 	}
 	
 	@Test
-	public void testStateIsActive() {
-		statemachine.enter();
+	public void stateIsActive() {
+		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/StatechartActiveTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.statechartactive.StatechartActiveStatemachine.State;
  * Unit TestCase for StatechartActive
  */
 @SuppressWarnings("all")
-public class StatechartActiveTest {
+public class StatechartActive {
 	private StatechartActiveStatemachine statemachine;	
 	
 	@Before
@@ -35,25 +35,25 @@ public class StatechartActiveTest {
 	}
 	
 	@Test
-	public void testInactiveBeforeEnter() {
+	public void inactiveBeforeEnter() {
 		assertTrue(!statemachine.isActive());
 	}
 	@Test
-	public void testActiveAfterEnter() {
-		statemachine.enter();
+	public void activeAfterEnter() {
+		statemachine.enter();;
 		assertTrue(statemachine.isActive());
 	}
 	@Test
-	public void testInactiveAfterExit() {
-		statemachine.enter();
-		statemachine.exit();
+	public void inactiveAfterExit() {
+		statemachine.enter();;
+		statemachine.exit();;
 		assertTrue(!statemachine.isActive());
 	}
 	@Test
-	public void testActiveAfterReenter() {
-		statemachine.enter();
-		statemachine.exit();
-		statemachine.enter();
+	public void activeAfterReenter() {
+		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/StatechartLocalReactionsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.statechartlocalreactions.StatechartLocalReactionsStatemac
  * Unit TestCase for StatechartLocalReactions
  */
 @SuppressWarnings("all")
-public class StatechartLocalReactionsTest {
+public class StatechartLocalReactions {
 	private StatechartLocalReactionsStatemachine statemachine;	
 	
 	@Before
@@ -35,8 +35,8 @@ public class StatechartLocalReactionsTest {
 	}
 	
 	@Test
-	public void testStatechartLocalReactionsTest() {
-		statemachine.enter();
+	public void statechartLocalReactionsTest() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.main_region_S1));
 		assertTrue(statemachine.isStateActive(State.region2_a));
 		while (statemachine.getMyInt() < 10l) {
@@ -47,7 +47,7 @@ public class StatechartLocalReactionsTest {
 			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/StatemachineKeywordsTest.java

@@ -21,7 +21,7 @@ import org.yakindu.scr.TimerService;
  * Unit TestCase for StatechartKeywords
  */
 @SuppressWarnings("all")
-public class StatemachineKeywordsTest {
+public class StatemachineKeywords {
 	private StatechartKeywordsStatemachine statemachine;	
 	
 	@Before
@@ -37,8 +37,8 @@ public class StatemachineKeywordsTest {
 	}
 	
 	@Test
-	public void testStatemachineKeywords() {
-		statemachine.enter();
+	public void statemachineKeywords() {
+		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/StaticChoiceTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.staticchoice.StaticChoiceStatemachine.State;
  * Unit TestCase for StaticChoice
  */
 @SuppressWarnings("all")
-public class StaticChoiceTest {
+public class StaticChoice {
 	private StaticChoiceStatemachine statemachine;	
 	
 	@Before
@@ -35,9 +35,9 @@ public class StaticChoiceTest {
 	}
 	
 	@Test
-	public void testStaticChoiceTest() {
-		statemachine.enter();
+	public void staticChoiceTest() {
+		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/StringExpressionsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.stringexpressions.StringExpressionsStatemachine.State;
  * Unit TestCase for StringExpressions
  */
 @SuppressWarnings("all")
-public class StringExpressionsTest {
+public class StringExpressions {
 	private StringExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -35,34 +35,34 @@ public class StringExpressionsTest {
 	}
 	
 	@Test
-	public void testStringExpressionsTest() {
+	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/SyncForkTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.syncfork.SyncForkStatemachine.State;
  * Unit TestCase for SyncFork
  */
 @SuppressWarnings("all")
-public class SyncForkTest {
+public class SyncFork {
 	private SyncForkStatemachine statemachine;	
 	
 	@Before
@@ -35,24 +35,24 @@ public class SyncForkTest {
 	}
 	
 	@Test
-	public void testSyncForkTest() {
-		statemachine.enter();
+	public void syncForkTest() {
+		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/SyncJoinTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.syncjoin.SyncJoinStatemachine.State;
  * Unit TestCase for SyncJoin
  */
 @SuppressWarnings("all")
-public class SyncJoinTest {
+public class SyncJoin {
 	private SyncJoinStatemachine statemachine;	
 	
 	@Before
@@ -35,82 +35,82 @@ public class SyncJoinTest {
 	}
 	
 	@Test
-	public void testSyncJoin_C2_Waits() {
-		statemachine.enter();
+	public void syncJoin_C2_Waits() {
+		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 testSyncJoin_D2_Waits() {
-		statemachine.enter();
+	public void syncJoin_D2_Waits() {
+		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 testDoubleEntryActionBug() {
-		statemachine.enter();
+	public void doubleEntryActionBug() {
+		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/TimedTransitionsTest.java

@@ -21,7 +21,7 @@ import org.yakindu.scr.TimerService;
  * Unit TestCase for TimedTransitions
  */
 @SuppressWarnings("all")
-public class TimedTransitionsTest {
+public class TimedTransitions {
 	private TimedTransitionsStatemachine statemachine;	
 	
 	@Before
@@ -37,11 +37,9 @@ public class TimedTransitionsTest {
 	}
 	
 	@Test
-	public void testTimer01() {
-		statemachine.enter();
+	public void timer01() {
+		statemachine.enter();;
 		assertTrue(statemachine.isStateActive(State.main_region_Start));
-		try {Thread.sleep(2030);} catch (InterruptedException e) {}
-		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/TransitionWithoutConditionTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.transitionwithoutcondition.TransitionWithoutConditionStat
  * Unit TestCase for TransitionWithoutCondition
  */
 @SuppressWarnings("all")
-public class TransitionWithoutConditionTest {
+public class TransitionWithoutCondition {
 	private TransitionWithoutConditionStatemachine statemachine;	
 	
 	@Before
@@ -35,10 +35,10 @@ public class TransitionWithoutConditionTest {
 	}
 	
 	@Test
-	public void testTransitionWithoutConditionTest() {
-		statemachine.enter();
+	public void transitionWithoutConditionTest() {
+		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/TriggerExpressionPrecedenceTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceSt
  * Unit TestCase for TriggerExpressionPrecedence
  */
 @SuppressWarnings("all")
-public class TriggerExpressionPrecedenceTest {
+public class TriggerExpressionPrecedence {
 	private TriggerExpressionPrecedenceStatemachine statemachine;	
 	
 	@Before
@@ -35,35 +35,35 @@ public class TriggerExpressionPrecedenceTest {
 	}
 	
 	@Test
-	public void testUnsatisfiedTriggerAndFGuardFalseOrFalse() {
-		statemachine.enter();
+	public void unsatisfiedTriggerAndFGuardFalseOrFalse() {
+		statemachine.enter();;
 		statemachine.setC1(false);
 		statemachine.setC2(false);
-		statemachine.runCycle();
+		statemachine.runCycle();;
 		assertTrue(!statemachine.getE1_transition());
 	}
 	@Test
-	public void testUnsatisfiedTriggerAndFGuardTrueOrFalse() {
-		statemachine.enter();
+	public void unsatisfiedTriggerAndFGuardTrueOrFalse() {
+		statemachine.enter();;
 		statemachine.setC1(true);
 		statemachine.setC2(false);
-		statemachine.runCycle();
+		statemachine.runCycle();;
 		assertTrue(!statemachine.getE1_transition());
 	}
 	@Test
-	public void testUnsatisfiedTriggerAndFGuardFalseOrTrue() {
-		statemachine.enter();
+	public void unsatisfiedTriggerAndFGuardFalseOrTrue() {
+		statemachine.enter();;
 		statemachine.setC1(false);
 		statemachine.setC2(true);
-		statemachine.runCycle();
+		statemachine.runCycle();;
 		assertTrue(!statemachine.getE1_transition());
 	}
 	@Test
-	public void testUnsatisfiedTriggerAndFGuardTrueOrTrue() {
-		statemachine.enter();
+	public void unsatisfiedTriggerAndFGuardTrueOrTrue() {
+		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/TriggerGuardExpressionsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.triggerguardexpressions.TriggerGuardExpressionsStatemachi
  * Unit TestCase for TriggerGuardExpressions
  */
 @SuppressWarnings("all")
-public class TriggerGuardExpressionsTest {
+public class TriggerGuardExpressions {
 	private TriggerGuardExpressionsStatemachine statemachine;	
 	
 	@Before
@@ -35,39 +35,39 @@ public class TriggerGuardExpressionsTest {
 	}
 	
 	@Test
-	public void testTrueGuard() {
-		statemachine.enter();
+	public void trueGuard() {
+		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 testFalseGuard() {
-		statemachine.enter();
+	public void falseGuard() {
+		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/TypeAliasTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.typealias.TypeAliasStatemachine.State;
  * Unit TestCase for TypeAlias
  */
 @SuppressWarnings("all")
-public class TypeAliasTest {
+public class TypeAlias {
 	private TypeAliasStatemachine statemachine;	
 	
 	@Before
@@ -35,17 +35,17 @@ public class TypeAliasTest {
 	}
 	
 	@Test
-	public void testTypeAliasTest() {
-		statemachine.enter();
+	public void typeAliasTest() {
+		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/ValuedEventsTest.java

@@ -20,7 +20,7 @@ import org.yakindu.scr.valuedevents.ValuedEventsStatemachine.State;
  * Unit TestCase for ValuedEvents
  */
 @SuppressWarnings("all")
-public class ValuedEventsTest {
+public class ValuedEvents {
 	private ValuedEventsStatemachine statemachine;	
 	
 	@Before
@@ -35,15 +35,15 @@ public class ValuedEventsTest {
 	}
 	
 	@Test
-	public void testValuedEventsTest() {
-		statemachine.enter();
-		statemachine.runCycle();
+	public void valuedEventsTest() {
+		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));