Adjust the Testmodels to the new SCTUnit syntax (#1303)

* Adjust the Testmodels to the new SCTUnit syntax

And generated Java Tests

* Added missing Java Tests

* Changed the structure of the SCTUnit Tests and Java Tests

test-plugins/org.yakindu.sct.generator.java.test/model/test.declarations.sgen

@@ -1,29 +0,0 @@
-GeneratorModel for sctunit::java {
-
-
-	test ConstOnlyInternalScope{
-		
-		feature Outlet{ 
-			targetProject = "org.yakindu.sct.generator.java.test" 
-			targetFolder = "test-gen"			
-		}			
-	}	
-	
-	
-	test ConstOnlyDefaultScope{
-		
-		feature Outlet{ 
-			targetProject = "org.yakindu.sct.generator.java.test" 
-			targetFolder = "test-gen"			
-		}			
-	}		
-		
-	test ConstOnlyNamedScope{
-		
-		feature Outlet{ 
-			targetProject = "org.yakindu.sct.generator.java.test" 
-			targetFolder = "test-gen"			
-		}			
-	}		
-
-}

test-plugins/org.yakindu.sct.generator.java.test/model/test.entries.sgen

@@ -1,12 +0,0 @@
-GeneratorModel for sctunit::java {
-	
-	test EntryReactionAction{
-		
-		feature Outlet{ 
-			targetProject = "org.yakindu.sct.generator.java.test" 
-			targetFolder = "test-gen"			
-		}			
-	}
-	
-}
-	

test-plugins/org.yakindu.sct.generator.java.test/model/test.expressions.sgen

@@ -1,12 +0,0 @@
-GeneratorModel for sctunit::java {
-	
-	test TriggerExpressionPrecedence {
-		
-		feature Outlet{ 
-			targetProject = "org.yakindu.sct.generator.java.test" 
-			targetFolder = "test-gen"			
-		}			
-	}
-
-
-}

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

@@ -1,34 +0,0 @@
-/**
-* Copyright (c) 2016 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, 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, 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,
-		TypeAliasTest.class, ValuedEventsTest.class})
-public class AllTestsTest {
-}

test-plugins/org.yakindu.sct.generator.java.test/test-gen/org/yakindu/sct/generator/java/test/tests/AllTestsTest.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.tests;
+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,
+	OperationsTest.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

@@ -1,56 +1,61 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.alwaysoncycle.AlwaysOncycleStatemachine;
-import org.yakindu.scr.alwaysoncycle.AlwaysOncycleStatemachine.State;
-/**
- *  Unit TestCase for AlwaysOncycle
- */
-@SuppressWarnings("all")
-public class AlwaysOncycleTest {
-
-	private AlwaysOncycleStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new AlwaysOncycleStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testalwaysOncycleTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		while (statemachine.getValue() < 5l) {
-			statemachine.runCycle();
-			assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		}
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		while (statemachine.getValue() < 5l) {
-			statemachine.runCycle();
-			assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		}
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.alwaysoncycle.AlwaysOncycleStatemachine;
+import org.yakindu.scr.alwaysoncycle.AlwaysOncycleStatemachine.State;
+
+/**
+ * Unit TestCase for AlwaysOncycle
+ */
+@SuppressWarnings("all")
+public class AlwaysOncycleTest {
+	private AlwaysOncycleStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new AlwaysOncycleStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testalwaysOncycleTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_StateA));
+		 
+		while (statemachine.getValue() < 5l) {
+			statemachine.runCycle();
+			assertTrue(statemachine.isStateActive(State.main_region_StateA));
+			 
+		}
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_StateB));
+		 
+		while (statemachine.getValue() < 5l) {
+			statemachine.runCycle();
+			assertTrue(statemachine.isStateActive(State.main_region_StateB));
+			 
+		}
+		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

@@ -1,72 +1,92 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.assignmentasexpression.AssignmentAsExpressionStatemachine;
-import org.yakindu.scr.assignmentasexpression.AssignmentAsExpressionStatemachine.State;
-/**
- *  Unit TestCase for AssignmentAsExpression
- */
-@SuppressWarnings("all")
-public class AssignmentAsExpressionTest {
-
-	private AssignmentAsExpressionStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new AssignmentAsExpressionStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testsimpleAssignment() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_Add));
-		assertTrue(statemachine.getB() == 5l);
-		assertTrue(statemachine.getA() == 9l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Subtract));
-		assertTrue(statemachine.getD() == 6l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Multiply));
-		assertTrue(statemachine.getE() == 15l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Divide));
-		assertTrue(statemachine.getG() == 1l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Modulo));
-		assertTrue(statemachine.getI() == 1l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Shift));
-		assertTrue(statemachine.getJ() == 16l);
-		assertTrue(statemachine.getK() == 4l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_boolean_And));
-		assertTrue(statemachine.getL() == 1l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_boolean_Or));
-		assertTrue(statemachine.getP() == 15l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_boolean_Xor));
-		assertTrue(statemachine.getU() == 12l);
-		statemachine.exit();
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.assignmentasexpression.AssignmentAsExpressionStatemachine;
+import org.yakindu.scr.assignmentasexpression.AssignmentAsExpressionStatemachine.State;
+
+/**
+ * Unit TestCase for AssignmentAsExpression
+ */
+@SuppressWarnings("all")
+public class AssignmentAsExpressionTest {
+	private AssignmentAsExpressionStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new AssignmentAsExpressionStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testsimpleAssignment() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_Add));
+		 
+		assertTrue(statemachine.getB() == 5l);
+		 
+		assertTrue(statemachine.getA() == 9l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Subtract));
+		 
+		assertTrue(statemachine.getD() == 6l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Multiply));
+		 
+		assertTrue(statemachine.getE() == 15l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Divide));
+		 
+		assertTrue(statemachine.getG() == 1l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Modulo));
+		 
+		assertTrue(statemachine.getI() == 1l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Shift));
+		 
+		assertTrue(statemachine.getJ() == 16l);
+		 
+		assertTrue(statemachine.getK() == 4l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_boolean_And));
+		 
+		assertTrue(statemachine.getL() == 1l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_boolean_Or));
+		 
+		assertTrue(statemachine.getP() == 15l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_boolean_Xor));
+		 
+		assertTrue(statemachine.getU() == 12l);
+		 
+		statemachine.exit();
+	}
+}

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

@@ -1,55 +1,65 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.bitexpressions.BitExpressionsStatemachine;
-import org.yakindu.scr.bitexpressions.BitExpressionsStatemachine.State;
-/**
- *  Unit TestCase for BitExpressions
- */
-@SuppressWarnings("all")
-public class BitExpressionsTest {
-
-	private BitExpressionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new BitExpressionsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testBitExpressions() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		assertTrue(statemachine.getMyBit1() == 5l);
-		assertTrue(statemachine.getMyBit2() == 7l);
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		assertTrue(statemachine.getLeftBitshift() == 10l);
-		assertTrue(statemachine.getRightBitshift() == 2l);
-		assertTrue(statemachine.getComplementBitshift() == -6l);
-		assertTrue(statemachine.getBitwiseAnd() == 5l);
-		assertTrue(statemachine.getBitwiseOr() == 7l);
-		assertTrue(statemachine.getBitwiseXor() == 2l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.bitexpressions.BitExpressionsStatemachine;
+import org.yakindu.scr.bitexpressions.BitExpressionsStatemachine.State;
+
+/**
+ * Unit TestCase for BitExpressions
+ */
+@SuppressWarnings("all")
+public class BitExpressionsTest {
+	private BitExpressionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new BitExpressionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testBitExpressions() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_StateA));
+		 
+		assertTrue(statemachine.getMyBit1() == 5l);
+		 
+		assertTrue(statemachine.getMyBit2() == 7l);
+		 
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_StateB));
+		 
+		assertTrue(statemachine.getLeftBitshift() == 10l);
+		 
+		assertTrue(statemachine.getRightBitshift() == 2l);
+		 
+		assertTrue(statemachine.getComplementBitshift() == - 6l );
+		 
+		assertTrue(statemachine.getBitwiseAnd() == 5l);
+		 
+		assertTrue(statemachine.getBitwiseOr() == 7l);
+		 
+		assertTrue(statemachine.getBitwiseXor() == 2l);
+		 
+	}
+}

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

@@ -1,54 +1,63 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.booleanexpressions.BooleanExpressionsStatemachine;
-import org.yakindu.scr.booleanexpressions.BooleanExpressionsStatemachine.State;
-/**
- *  Unit TestCase for BooleanExpressions
- */
-@SuppressWarnings("all")
-public class BooleanExpressionsTest {
-
-	private BooleanExpressionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new BooleanExpressionsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testbooleanExpressions() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		assertTrue(statemachine.getMyBool1() == true);
-		assertTrue(statemachine.getMyBool2() == false);
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		assertTrue(statemachine.getAnd() == false);
-		assertTrue(statemachine.getOr() == true);
-		assertTrue(statemachine.getNot() == false);
-		assertTrue(statemachine.getEqual() == false);
-		assertTrue(statemachine.getNotequal() == true);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.booleanexpressions.BooleanExpressionsStatemachine;
+import org.yakindu.scr.booleanexpressions.BooleanExpressionsStatemachine.State;
+
+/**
+ * Unit TestCase for BooleanExpressions
+ */
+@SuppressWarnings("all")
+public class BooleanExpressionsTest {
+	private BooleanExpressionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new BooleanExpressionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testbooleanExpressions() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_StateA));
+		 
+		assertTrue(statemachine.getMyBool1() == true);
+		 
+		assertTrue(statemachine.getMyBool2() == false);
+		 
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_StateB));
+		 
+		assertTrue(statemachine.getAnd() == false);
+		 
+		assertTrue(statemachine.getOr() == true);
+		 
+		assertTrue(statemachine.getNot() == false);
+		 
+		assertTrue(statemachine.getEqual() == false);
+		 
+		assertTrue(statemachine.getNotequal() == true);
+		 
+	}
+}

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

@@ -1,49 +1,53 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.ckeywords.CKeywordsStatemachine;
-import org.yakindu.scr.ckeywords.CKeywordsStatemachine.State;
-/**
- *  Unit TestCase for CKeywords
- */
-@SuppressWarnings("all")
-public class CKeywordsTest {
-
-	private CKeywordsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new CKeywordsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testCKeywordsTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.auto_char));
-		statemachine.raiseAuto();
-		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));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.ckeywords.CKeywordsStatemachine;
+import org.yakindu.scr.ckeywords.CKeywordsStatemachine.State;
+
+/**
+ * Unit TestCase for CKeywords
+ */
+@SuppressWarnings("all")
+public class CKeywordsTest {
+	private CKeywordsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new CKeywordsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testCKeywordsTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.auto_char));
+		 
+		statemachine.raiseAuto();
+		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

@@ -1,50 +1,55 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.castexpressions.CastExpressionsStatemachine;
-import org.yakindu.scr.castexpressions.CastExpressionsStatemachine.State;
-/**
- *  Unit TestCase for CastExpressions
- */
-@SuppressWarnings("all")
-public class CastExpressionsTest {
-
-	private CastExpressionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new CastExpressionsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testCastExpressionTest() {
-		statemachine.enter();
-		assertTrue(statemachine.getRealValue() == 5l);
-		assertTrue(statemachine.getIntValue() == 5l);
-		statemachine.runCycle();
-		assertTrue(statemachine.getRealValue() == 15l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_C));
-		assertTrue(statemachine.getRealValue() == 757l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.castexpressions.CastExpressionsStatemachine;
+import org.yakindu.scr.castexpressions.CastExpressionsStatemachine.State;
+
+/**
+ * Unit TestCase for CastExpressions
+ */
+@SuppressWarnings("all")
+public class CastExpressionsTest {
+	private CastExpressionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new CastExpressionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testCastExpressionTest() {
+		statemachine.enter();
+		assertTrue(statemachine.getRealValue() == 5l);
+		 
+		assertTrue(statemachine.getIntValue() == 5l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.getRealValue() == 15l);
+		 
+		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

@@ -1,102 +1,116 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.choice.ChoiceStatemachine;
-import org.yakindu.scr.choice.ChoiceStatemachine.State;
-/**
- *  Unit TestCase for Choice
- */
-@SuppressWarnings("all")
-public class ChoiceTest {
-
-	private ChoiceStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ChoiceStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testelseChoiceUsingNonDefaultTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.setC(true);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_C));
-	}
-	@Test
-	public void testelseChoiceUsingDefaultTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.setC(false);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-	}
-	@Test
-	public void testdefaultChoiceUsingNonDefaultTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.setC(true);
-		statemachine.raiseG();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_C));
-	}
-	@Test
-	public void testdefaultChoiceUsingDefaultTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.setC(false);
-		statemachine.raiseG();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-	}
-	@Test
-	public void testuncheckedChoiceUsingNonDefaultTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.setC(true);
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_C));
-	}
-	@Test
-	public void testuncheckedChoiceUsingDefaultTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.setC(false);
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-	}
-	@Test
-	public void testalwaysTrueTransitionInChoice() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.setC(true);
-		statemachine.raiseH();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_C));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.choice.ChoiceStatemachine;
+import org.yakindu.scr.choice.ChoiceStatemachine.State;
+
+/**
+ * Unit TestCase for Choice
+ */
+@SuppressWarnings("all")
+public class ChoiceTest {
+	private ChoiceStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ChoiceStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testelseChoiceUsingNonDefaultTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.setC(true);
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_C));
+		 
+	}
+	@Test
+	public void testelseChoiceUsingDefaultTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.setC(false);
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+	}
+	@Test
+	public void testdefaultChoiceUsingNonDefaultTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.setC(true);
+		statemachine.raiseG();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_C));
+		 
+	}
+	@Test
+	public void testdefaultChoiceUsingDefaultTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.setC(false);
+		statemachine.raiseG();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+	}
+	@Test
+	public void testuncheckedChoiceUsingNonDefaultTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.setC(true);
+		statemachine.raiseF();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_C));
+		 
+	}
+	@Test
+	public void testuncheckedChoiceUsingDefaultTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.setC(false);
+		statemachine.raiseF();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+	}
+	@Test
+	public void testalwaysTrueTransitionInChoice() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.setC(true);
+		statemachine.raiseH();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_C));
+		 
+	}
+}

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

@@ -1,49 +1,53 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.conditionalexpressions.ConditionalExpressionsStatemachine;
-import org.yakindu.scr.conditionalexpressions.ConditionalExpressionsStatemachine.State;
-/**
- *  Unit TestCase for ConditionalExpressions
- */
-@SuppressWarnings("all")
-public class ConditionalExpressionTest {
-
-	private ConditionalExpressionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ConditionalExpressionsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testConditionalExpressionTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		assertTrue(statemachine.getCondition() == 1l);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		assertTrue(statemachine.getCondition() == 2l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.conditionalexpressions.ConditionalExpressionsStatemachine;
+import org.yakindu.scr.conditionalexpressions.ConditionalExpressionsStatemachine.State;
+
+/**
+ * Unit TestCase for ConditionalExpressions
+ */
+@SuppressWarnings("all")
+public class ConditionalExpressionTest {
+	private ConditionalExpressionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ConditionalExpressionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testConditionalExpressionTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		assertTrue(statemachine.getCondition() == 1l);
+		 
+		statemachine.raiseE();
+		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

@@ -1,51 +1,53 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.constonlydefaultscope.ConstOnlyDefaultScopeStatemachine;
-import org.yakindu.scr.constonlydefaultscope.ConstOnlyDefaultScopeStatemachine.State;
-/**
- *  Unit TestCase for ConstOnlyDefaultScope
- */
-@SuppressWarnings("all")
-public class ConstOnlyDefaultScopeTest {
-
-	private ConstOnlyDefaultScopeStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ConstOnlyDefaultScopeStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void teststatechartEntry() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.constOnlyDefaultScope_main_region_A));
-	}
-	@Test
-	public void teststateTransition() {
-		statemachine.enter();
-		statemachine.getSCIA().raiseE(1l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.constOnlyDefaultScope_main_region_B));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.constonlydefaultscope.ConstOnlyDefaultScopeStatemachine;
+import org.yakindu.scr.constonlydefaultscope.ConstOnlyDefaultScopeStatemachine.State;
+
+/**
+ * Unit TestCase for ConstOnlyDefaultScope
+ */
+@SuppressWarnings("all")
+public class ConstOnlyDefaultScopeTest {
+	private ConstOnlyDefaultScopeStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ConstOnlyDefaultScopeStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void teststatechartEntry() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.constOnlyDefaultScope_main_region_A));
+		 
+	}
+	@Test
+	public void teststateTransition() {
+		statemachine.enter();
+		statemachine.getSCIA().raiseE(1l);
+		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

@@ -1,51 +1,53 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.constonlyinternalscope.ConstOnlyInternalScopeStatemachine;
-import org.yakindu.scr.constonlyinternalscope.ConstOnlyInternalScopeStatemachine.State;
-/**
- *  Unit TestCase for ConstOnlyInternalScope
- */
-@SuppressWarnings("all")
-public class ConstOnlyInternalScopeTest {
-
-	private ConstOnlyInternalScopeStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ConstOnlyInternalScopeStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void teststatechartEntry() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.constOnlyInternalScope_main_region_A));
-	}
-	@Test
-	public void teststateTransition() {
-		statemachine.enter();
-		statemachine.raiseE(1l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.constOnlyInternalScope_main_region_B));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.constonlyinternalscope.ConstOnlyInternalScopeStatemachine;
+import org.yakindu.scr.constonlyinternalscope.ConstOnlyInternalScopeStatemachine.State;
+
+/**
+ * Unit TestCase for ConstOnlyInternalScope
+ */
+@SuppressWarnings("all")
+public class ConstOnlyInternalScopeTest {
+	private ConstOnlyInternalScopeStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ConstOnlyInternalScopeStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void teststatechartEntry() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.constOnlyInternalScope_main_region_A));
+		 
+	}
+	@Test
+	public void teststateTransition() {
+		statemachine.enter();
+		statemachine.raiseE(1l);
+		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

@@ -1,51 +1,53 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.constonlynamedscope.ConstOnlyNamedScopeStatemachine;
-import org.yakindu.scr.constonlynamedscope.ConstOnlyNamedScopeStatemachine.State;
-/**
- *  Unit TestCase for ConstOnlyNamedScope
- */
-@SuppressWarnings("all")
-public class ConstOnlyNamedScopeTest {
-
-	private ConstOnlyNamedScopeStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ConstOnlyNamedScopeStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void teststatechartEntry() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.constOnlyNamedScope_main_region_A));
-	}
-	@Test
-	public void teststateTransition() {
-		statemachine.enter();
-		statemachine.raiseE(1l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.constOnlyNamedScope_main_region_B));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.constonlynamedscope.ConstOnlyNamedScopeStatemachine;
+import org.yakindu.scr.constonlynamedscope.ConstOnlyNamedScopeStatemachine.State;
+
+/**
+ * Unit TestCase for ConstOnlyNamedScope
+ */
+@SuppressWarnings("all")
+public class ConstOnlyNamedScopeTest {
+	private ConstOnlyNamedScopeStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ConstOnlyNamedScopeStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void teststatechartEntry() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.constOnlyNamedScope_main_region_A));
+		 
+	}
+	@Test
+	public void teststateTransition() {
+		statemachine.enter();
+		statemachine.raiseE(1l);
+		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

@@ -1,58 +1,67 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.constants.ConstantsStatemachine;
-import org.yakindu.scr.constants.ConstantsStatemachine.State;
-/**
- *  Unit TestCase for Constants
- */
-@SuppressWarnings("all")
-public class ConstantsTestsTest {
-
-	private ConstantsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ConstantsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testconstantDefinition() {
-		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();
-		assertTrue(statemachine.getResult() == 20l);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_C));
-		assertTrue(statemachine.getResult() == 100l);
-		statemachine.raiseE2(statemachine.getX());
-		statemachine.runCycle();
-		assertTrue(statemachine.getResult() == 1000l);
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.constants.ConstantsStatemachine;
+import org.yakindu.scr.constants.ConstantsStatemachine.State;
+
+/**
+ * Unit TestCase for Constants
+ */
+@SuppressWarnings("all")
+public class ConstantsTestsTest {
+	private ConstantsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ConstantsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testconstantDefinition() {
+		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();
+		assertTrue(statemachine.getResult() == 20l);
+		 
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_C));
+		 
+		assertTrue(statemachine.getResult() == 100l);
+		 
+		statemachine.raiseE2(statemachine.getX());
+		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

@@ -1,43 +1,43 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.declarations.DeclarationsStatemachine;
-import org.yakindu.scr.declarations.DeclarationsStatemachine.State;
-/**
- *  Unit TestCase for Declarations
- */
-@SuppressWarnings("all")
-public class DeclarationsTest {
-
-	private DeclarationsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new DeclarationsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testdeclarationsTest() {
-		statemachine.enter();
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.declarations.DeclarationsStatemachine;
+import org.yakindu.scr.declarations.DeclarationsStatemachine.State;
+
+/**
+ * Unit TestCase for Declarations
+ */
+@SuppressWarnings("all")
+public class DeclarationsTest {
+	private DeclarationsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new DeclarationsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testdeclarationsTest() {
+		statemachine.enter();
+	}
+}

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

@@ -1,59 +1,69 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-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);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+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

@@ -1,62 +1,67 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.deephistory.DeepHistoryStatemachine;
-import org.yakindu.scr.deephistory.DeepHistoryStatemachine.State;
-/**
- *  Unit TestCase for DeepHistory
- */
-@SuppressWarnings("all")
-public class DeepHistoryTest {
-
-	private DeepHistoryStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new DeepHistoryStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testdeepHistoryTest() {
-		statemachine.enter();
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		statemachine.raiseEvent3();
-		statemachine.runCycle();
-		statemachine.raiseEvent5();
-		statemachine.runCycle();
-		statemachine.raiseEvent7();
-		statemachine.runCycle();
-		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
-		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
-		statemachine.raiseEvent2();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.mainRegion_State1));
-		assertTrue(
-				!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
-		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.deephistory.DeepHistoryStatemachine;
+import org.yakindu.scr.deephistory.DeepHistoryStatemachine.State;
+
+/**
+ * Unit TestCase for DeepHistory
+ */
+@SuppressWarnings("all")
+public class DeepHistoryTest {
+	private DeepHistoryStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new DeepHistoryStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testdeepHistoryTest() {
+		statemachine.enter();
+		statemachine.raiseEvent1();
+		statemachine.runCycle();
+		statemachine.raiseEvent3();
+		statemachine.runCycle();
+		statemachine.raiseEvent5();
+		statemachine.runCycle();
+		statemachine.raiseEvent7();
+		statemachine.runCycle();
+		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
+		 
+		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		 
+		statemachine.raiseEvent2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.mainRegion_State1));
+		 
+		assertTrue(!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		 
+		statemachine.raiseEvent1();
+		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

@@ -1,46 +1,48 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.dynamicchoice.DynamicChoiceStatemachine;
-import org.yakindu.scr.dynamicchoice.DynamicChoiceStatemachine.State;
-/**
- *  Unit TestCase for DynamicChoice
- */
-@SuppressWarnings("all")
-public class DynamicChoiceTest {
-
-	private DynamicChoiceStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new DynamicChoiceStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testDynamicChoiceTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_Start));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.dynamicchoice.DynamicChoiceStatemachine;
+import org.yakindu.scr.dynamicchoice.DynamicChoiceStatemachine.State;
+
+/**
+ * Unit TestCase for DynamicChoice
+ */
+@SuppressWarnings("all")
+public class DynamicChoiceTest {
+	private DynamicChoiceStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new DynamicChoiceStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testDynamicChoiceTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_Start));
+		 
+		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

@@ -1,46 +1,48 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.emptytransition.EmptyTransitionStatemachine;
-import org.yakindu.scr.emptytransition.EmptyTransitionStatemachine.State;
-/**
- *  Unit TestCase for EmptyTransition
- */
-@SuppressWarnings("all")
-public class EmptyTransitionTest {
-
-	private EmptyTransitionStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new EmptyTransitionStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testEmptyTransitionTest() {
-		statemachine.enter();
-		statemachine.runCycle();
-		assertTrue(!statemachine.isStateActive(State.main_region_B));
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.emptytransition.EmptyTransitionStatemachine;
+import org.yakindu.scr.emptytransition.EmptyTransitionStatemachine.State;
+
+/**
+ * Unit TestCase for EmptyTransition
+ */
+@SuppressWarnings("all")
+public class EmptyTransitionTest {
+	private EmptyTransitionStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new EmptyTransitionStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testEmptyTransitionTest() {
+		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

@@ -1,63 +1,69 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.enterstate.EnterStateStatemachine;
-import org.yakindu.scr.enterstate.EnterStateStatemachine.State;
-/**
- *  Unit TestCase for EnterState
- */
-@SuppressWarnings("all")
-public class EnterStateTest {
-
-	private EnterStateStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new EnterStateStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testdefaultEntry() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.r_A));
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r_B_r_E));
-	}
-	@Test
-	public void testnamedEntryThroughNamedTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.r_A));
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r_B_r_F));
-	}
-	@Test
-	public void testnamedEntryThroughDefaultTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.r_A));
-		statemachine.raiseG();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r_B_r_E));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.enterstate.EnterStateStatemachine;
+import org.yakindu.scr.enterstate.EnterStateStatemachine.State;
+
+/**
+ * Unit TestCase for EnterState
+ */
+@SuppressWarnings("all")
+public class EnterStateTest {
+	private EnterStateStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new EnterStateStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testdefaultEntry() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.r_A));
+		 
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.r_B_r_E));
+		 
+	}
+	@Test
+	public void testnamedEntryThroughNamedTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.r_A));
+		 
+		statemachine.raiseF();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.r_B_r_F));
+		 
+	}
+	@Test
+	public void testnamedEntryThroughDefaultTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.r_A));
+		 
+		statemachine.raiseG();
+		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

@@ -1,46 +1,47 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.entrychoice.EntryChoiceStatemachine;
-import org.yakindu.scr.entrychoice.EntryChoiceStatemachine.State;
-/**
- *  Unit TestCase for EntryChoice
- */
-@SuppressWarnings("all")
-public class EntryChoiceTest {
-
-	private EntryChoiceStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new EntryChoiceStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testEntryChoiceTest() {
-		statemachine.enter();
-		statemachine.runCycle();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.entrychoice.EntryChoiceStatemachine;
+import org.yakindu.scr.entrychoice.EntryChoiceStatemachine.State;
+
+/**
+ * Unit TestCase for EntryChoice
+ */
+@SuppressWarnings("all")
+public class EntryChoiceTest {
+	private EntryChoiceStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new EntryChoiceStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testEntryChoiceTest() {
+		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

@@ -1,69 +1,81 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.entryexitselftransition.EntryExitSelfTransitionStatemachine;
-import org.yakindu.scr.entryexitselftransition.EntryExitSelfTransitionStatemachine.State;
-/**
- *  Unit TestCase for EntryExitSelfTransition
- */
-@SuppressWarnings("all")
-public class EntryExitSelfTransitionTest {
-
-	private EntryExitSelfTransitionStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new EntryExitSelfTransitionStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testSelfTransitionToChildState() {
-		statemachine.enter();
-		statemachine.runCycle();
-		assertTrue(statemachine.getEntries() == 1l);
-		assertTrue(statemachine.isStateActive(State.main_region_A__region0_B));
-		statemachine.setEntries(0l);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.getEntries() == 1l);
-		assertTrue(statemachine.getExits() == 1l);
-		assertTrue(statemachine.isStateActive(State.main_region_A__region0_C));
-	}
-	@Test
-	public void testSelfTransitionFromChildState() {
-		statemachine.enter();
-		statemachine.runCycle();
-		assertTrue(statemachine.getEntries() == 1l);
-		statemachine.setEntries(0l);
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.getEntries() == 0l);
-		assertTrue(statemachine.getExits() == 0l);
-		assertTrue(statemachine.isStateActive(State.main_region_A__region0_C));
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A__region0_B));
-		assertTrue(statemachine.getEntries() == 1l);
-		assertTrue(statemachine.getExits() == 1l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.entryexitselftransition.EntryExitSelfTransitionStatemachine;
+import org.yakindu.scr.entryexitselftransition.EntryExitSelfTransitionStatemachine.State;
+
+/**
+ * Unit TestCase for EntryExitSelfTransition
+ */
+@SuppressWarnings("all")
+public class EntryExitSelfTransitionTest {
+	private EntryExitSelfTransitionStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new EntryExitSelfTransitionStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testSelfTransitionToChildState() {
+		statemachine.enter();
+		statemachine.runCycle();
+		assertTrue(statemachine.getEntries() == 1l);
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_A__region0_B));
+		 
+		statemachine.setEntries(0l);
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.getEntries() == 1l);
+		 
+		assertTrue(statemachine.getExits() == 1l);
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_A__region0_C));
+		 
+	}
+	@Test
+	public void testSelfTransitionFromChildState() {
+		statemachine.enter();
+		statemachine.runCycle();
+		assertTrue(statemachine.getEntries() == 1l);
+		 
+		statemachine.setEntries(0l);
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.getEntries() == 0l);
+		 
+		assertTrue(statemachine.getExits() == 0l);
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_A__region0_C));
+		 
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A__region0_B));
+		 
+		assertTrue(statemachine.getEntries() == 1l);
+		 
+		assertTrue(statemachine.getExits() == 1l);
+		 
+	}
+}

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

@@ -1,83 +1,95 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.entryreactionaction.EntryReactionActionStatemachine;
-import org.yakindu.scr.entryreactionaction.EntryReactionActionStatemachine.State;
-/**
- *  Unit TestCase for EntryReactionAction
- */
-@SuppressWarnings("all")
-public class EntryReactionActionTest {
-
-	private EntryReactionActionStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new EntryReactionActionStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testentryTransitionActionOnStatechartEnter() {
-		statemachine.enter();
-		assertTrue(statemachine.getEnteredR1());
-		assertTrue(statemachine.getEnteredR2());
-		assertTrue(statemachine.getEnteredBdefault());
-		assertTrue(!statemachine.getEnteredBother());
-	}
-	@Test
-	public void testentryOnRTS() {
-		statemachine.enter();
-		statemachine.raiseB();
-		statemachine.runCycle();
-		statemachine.raiseD();
-		statemachine.runCycle();
-		statemachine.setEnteredR1(false);
-		statemachine.setEnteredR2(false);
-		statemachine.setEnteredBdefault(false);
-		statemachine.setEnteredBother(false);
-		statemachine.raiseB();
-		statemachine.runCycle();
-		assertTrue(!statemachine.getEnteredR1());
-		assertTrue(!statemachine.getEnteredR2());
-		assertTrue(!statemachine.getEnteredBdefault());
-		assertTrue(statemachine.getEnteredBother());
-	}
-	@Test
-	public void testnoEntryTransitionActionOnHistory() {
-		statemachine.enter();
-		statemachine.raiseB();
-		statemachine.runCycle();
-		statemachine.raiseD();
-		statemachine.runCycle();
-		statemachine.setEnteredR1(false);
-		statemachine.setEnteredR2(false);
-		statemachine.setEnteredBdefault(false);
-		statemachine.setEnteredBother(false);
-		statemachine.raiseD();
-		statemachine.runCycle();
-		assertTrue(!statemachine.getEnteredR1());
-		assertTrue(!statemachine.getEnteredR2());
-		assertTrue(!statemachine.getEnteredBdefault());
-		assertTrue(!statemachine.getEnteredBother());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.entryreactionaction.EntryReactionActionStatemachine;
+import org.yakindu.scr.entryreactionaction.EntryReactionActionStatemachine.State;
+
+/**
+ * Unit TestCase for EntryReactionAction
+ */
+@SuppressWarnings("all")
+public class EntryReactionActionTest {
+	private EntryReactionActionStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new EntryReactionActionStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testentryTransitionActionOnStatechartEnter() {
+		statemachine.enter();
+		assertTrue(statemachine.getEnteredR1());
+		 
+		assertTrue(statemachine.getEnteredR2());
+		 
+		assertTrue(statemachine.getEnteredBdefault());
+		 
+		assertTrue(!statemachine.getEnteredBother());
+		 
+	}
+	@Test
+	public void testentryOnRTS() {
+		statemachine.enter();
+		statemachine.raiseB();
+		statemachine.runCycle();
+		statemachine.raiseD();
+		statemachine.runCycle();
+		statemachine.setEnteredR1(false);
+		statemachine.setEnteredR2(false);
+		statemachine.setEnteredBdefault(false);
+		statemachine.setEnteredBother(false);
+		statemachine.raiseB();
+		statemachine.runCycle();
+		assertTrue(!statemachine.getEnteredR1());
+		 
+		assertTrue(!statemachine.getEnteredR2());
+		 
+		assertTrue(!statemachine.getEnteredBdefault());
+		 
+		assertTrue(statemachine.getEnteredBother());
+		 
+	}
+	@Test
+	public void testnoEntryTransitionActionOnHistory() {
+		statemachine.enter();
+		statemachine.raiseB();
+		statemachine.runCycle();
+		statemachine.raiseD();
+		statemachine.runCycle();
+		statemachine.setEnteredR1(false);
+		statemachine.setEnteredR2(false);
+		statemachine.setEnteredBdefault(false);
+		statemachine.setEnteredBother(false);
+		statemachine.raiseD();
+		statemachine.runCycle();
+		assertTrue(!statemachine.getEnteredR1());
+		 
+		assertTrue(!statemachine.getEnteredR2());
+		 
+		assertTrue(!statemachine.getEnteredBdefault());
+		 
+		assertTrue(!statemachine.getEnteredBother());
+		 
+	}
+}

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

@@ -1,54 +1,61 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.exitonselftransition.ExitOnSelfTransitionStatemachine;
-import org.yakindu.scr.exitonselftransition.ExitOnSelfTransitionStatemachine.State;
-/**
- *  Unit TestCase for ExitOnSelfTransition
- */
-@SuppressWarnings("all")
-public class ExitOnSelfTransitionTest {
-
-	private ExitOnSelfTransitionStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ExitOnSelfTransitionStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testExitOnSelfTransitionTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		assertTrue(statemachine.getEntryCount() == 1l);
-		assertTrue(statemachine.getExitCount() == 0l);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.getEntryCount() == 2l);
-		assertTrue(statemachine.getExitCount() == 1l);
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.getEntryCount() == 2l);
-		assertTrue(statemachine.getExitCount() == 2l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.exitonselftransition.ExitOnSelfTransitionStatemachine;
+import org.yakindu.scr.exitonselftransition.ExitOnSelfTransitionStatemachine.State;
+
+/**
+ * Unit TestCase for ExitOnSelfTransition
+ */
+@SuppressWarnings("all")
+public class ExitOnSelfTransitionTest {
+	private ExitOnSelfTransitionStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ExitOnSelfTransitionStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testExitOnSelfTransitionTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		assertTrue(statemachine.getEntryCount() == 1l);
+		 
+		assertTrue(statemachine.getExitCount() == 0l);
+		 
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.getEntryCount() == 2l);
+		 
+		assertTrue(statemachine.getExitCount() == 1l);
+		 
+		statemachine.raiseF();
+		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

@@ -1,70 +1,78 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.exitstate.ExitStateStatemachine;
-import org.yakindu.scr.exitstate.ExitStateStatemachine.State;
-/**
- *  Unit TestCase for ExitState
- */
-@SuppressWarnings("all")
-public class ExitStateTest {
-
-	private ExitStateStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ExitStateStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testdefaultExit() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.r_A));
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r_E));
-	}
-	@Test
-	public void testnamedExitThroughNamedTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.r_A));
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r_F));
-	}
-	@Test
-	public void testnamedExitThroughDefaultTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.r_A));
-		statemachine.raiseG();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r_E));
-	}
-	@Test
-	public void testremainInA() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.r_A));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r_A));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.exitstate.ExitStateStatemachine;
+import org.yakindu.scr.exitstate.ExitStateStatemachine.State;
+
+/**
+ * Unit TestCase for ExitState
+ */
+@SuppressWarnings("all")
+public class ExitStateTest {
+	private ExitStateStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ExitStateStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testdefaultExit() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.r_A));
+		 
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.r_E));
+		 
+	}
+	@Test
+	public void testnamedExitThroughNamedTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.r_A));
+		 
+		statemachine.raiseF();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.r_F));
+		 
+	}
+	@Test
+	public void testnamedExitThroughDefaultTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.r_A));
+		 
+		statemachine.raiseG();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.r_E));
+		 
+	}
+	@Test
+	public void testremainInA() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.r_A));
+		 
+		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

@@ -1,46 +1,48 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.featurecalls.FeatureCallsStatemachine;
-import org.yakindu.scr.featurecalls.FeatureCallsStatemachine.State;
-/**
- *  Unit TestCase for FeatureCalls
- */
-@SuppressWarnings("all")
-public class FeatureCallsTest {
-
-	private FeatureCallsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new FeatureCallsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testFeatureCalls() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.featurecalls.FeatureCallsStatemachine;
+import org.yakindu.scr.featurecalls.FeatureCallsStatemachine.State;
+
+/**
+ * Unit TestCase for FeatureCalls
+ */
+@SuppressWarnings("all")
+public class FeatureCallsTest {
+	private FeatureCallsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new FeatureCallsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testFeatureCalls() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		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

@@ -1,45 +1,46 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.finalstate.FinalStateStatemachine;
-import org.yakindu.scr.finalstate.FinalStateStatemachine.State;
-/**
- *  Unit TestCase for FinalState
- */
-@SuppressWarnings("all")
-public class FinalStateTest {
-
-	private FinalStateStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new FinalStateStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testStatechartNameTest() {
-		statemachine.enter();
-		statemachine.runCycle();
-		assertTrue(statemachine.isFinal());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.finalstate.FinalStateStatemachine;
+import org.yakindu.scr.finalstate.FinalStateStatemachine.State;
+
+/**
+ * Unit TestCase for FinalState
+ */
+@SuppressWarnings("all")
+public class FinalStateTest {
+	private FinalStateStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new FinalStateStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testStatechartNameTest() {
+		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

@@ -1,59 +1,65 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.guard.GuardStatemachine;
-import org.yakindu.scr.guard.GuardStatemachine.State;
-/**
- *  Unit TestCase for Guard
- */
-@SuppressWarnings("all")
-public class GuardTest {
-
-	private GuardStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new GuardStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testguardTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseEvent2();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		statemachine.raiseReturn();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		statemachine.raiseReturn();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.guard.GuardStatemachine;
+import org.yakindu.scr.guard.GuardStatemachine.State;
+
+/**
+ * Unit TestCase for Guard
+ */
+@SuppressWarnings("all")
+public class GuardTest {
+	private GuardStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new GuardStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testguardTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseEvent1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseEvent2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+		statemachine.raiseReturn();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseEvent1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+		statemachine.raiseReturn();
+		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

@@ -1,81 +1,94 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.guardedentry.GuardedEntryStatemachine;
-import org.yakindu.scr.guardedentry.GuardedEntryStatemachine.State;
-/**
- *  Unit TestCase for GuardedEntry
- */
-@SuppressWarnings("all")
-public class GuardedEntryTest {
-
-	private GuardedEntryStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new GuardedEntryStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testEntryNotTakenOnStatechartEnter() {
-		assertTrue(statemachine.getGuard() == false);
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		assertTrue(statemachine.getDone() == false);
-	}
-	@Test
-	public void testEntryTakenOnStatechartEnter() {
-		statemachine.setGuard(true);
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		assertTrue(statemachine.getDone() == true);
-	}
-	@Test
-	public void testEntryTakenInTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		statemachine.setGuard(true);
-		statemachine.setDone(false);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		assertTrue(statemachine.getDone());
-	}
-	@Test
-	public void testEntryNotTakenInTransition() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		statemachine.setGuard(false);
-		statemachine.setDone(false);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		assertTrue(!statemachine.getDone());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.guardedentry.GuardedEntryStatemachine;
+import org.yakindu.scr.guardedentry.GuardedEntryStatemachine.State;
+
+/**
+ * Unit TestCase for GuardedEntry
+ */
+@SuppressWarnings("all")
+public class GuardedEntryTest {
+	private GuardedEntryStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new GuardedEntryStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testEntryNotTakenOnStatechartEnter() {
+		assertTrue(statemachine.getGuard() == false);
+		 
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		assertTrue(statemachine.getDone() == false);
+		 
+	}
+	@Test
+	public void testEntryTakenOnStatechartEnter() {
+		statemachine.setGuard(true);
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		assertTrue(statemachine.getDone() == true);
+		 
+	}
+	@Test
+	public void testEntryTakenInTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+		statemachine.setGuard(true);
+		statemachine.setDone(false);
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		assertTrue(statemachine.getDone());
+		 
+	}
+	@Test
+	public void testEntryNotTakenInTransition() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+		statemachine.setGuard(false);
+		statemachine.setDone(false);
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		assertTrue(!statemachine.getDone());
+		 
+	}
+}

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

@@ -1,59 +1,66 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.guardedexit.GuardedExitStatemachine;
-import org.yakindu.scr.guardedexit.GuardedExitStatemachine.State;
-/**
- *  Unit TestCase for GuardedExit
- */
-@SuppressWarnings("all")
-public class GuardedExitTest {
-
-	private GuardedExitStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new GuardedExitStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testExitTaken() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		assertTrue(!statemachine.getGuard());
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		assertTrue(!statemachine.getDone());
-	}
-	@Test
-	public void testExitNotTaken() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.setGuard(true);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		assertTrue(statemachine.getDone());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.guardedexit.GuardedExitStatemachine;
+import org.yakindu.scr.guardedexit.GuardedExitStatemachine.State;
+
+/**
+ * Unit TestCase for GuardedExit
+ */
+@SuppressWarnings("all")
+public class GuardedExitTest {
+	private GuardedExitStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new GuardedExitStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testExitTaken() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		assertTrue(!statemachine.getGuard());
+		 
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+		assertTrue(!statemachine.getDone());
+		 
+	}
+	@Test
+	public void testExitNotTaken() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.setGuard(true);
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+		assertTrue(statemachine.getDone());
+		 
+	}
+}

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

@@ -1,59 +1,65 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.historywithexitpoint.HistoryWithExitPointStatemachine;
-import org.yakindu.scr.historywithexitpoint.HistoryWithExitPointStatemachine.State;
-/**
- *  Unit TestCase for HistoryWithExitPoint
- */
-@SuppressWarnings("all")
-public class HistoryWithExitPointTest {
-
-	private HistoryWithExitPointStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new HistoryWithExitPointStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testhistoryEntryAfterExit() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.mr_A_r_X1));
-		statemachine.raisePush();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.mr_B));
-		statemachine.raiseBack();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.mr_A_r_X1));
-		statemachine.raiseNext();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.mr_A_r_X2));
-		statemachine.raisePush();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.mr_B));
-		statemachine.raiseBack();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.mr_A_r_X2));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.historywithexitpoint.HistoryWithExitPointStatemachine;
+import org.yakindu.scr.historywithexitpoint.HistoryWithExitPointStatemachine.State;
+
+/**
+ * Unit TestCase for HistoryWithExitPoint
+ */
+@SuppressWarnings("all")
+public class HistoryWithExitPointTest {
+	private HistoryWithExitPointStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new HistoryWithExitPointStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testhistoryEntryAfterExit() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.mr_A_r_X1));
+		 
+		statemachine.raisePush();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.mr_B));
+		 
+		statemachine.raiseBack();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.mr_A_r_X1));
+		 
+		statemachine.raiseNext();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.mr_A_r_X2));
+		 
+		statemachine.raisePush();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.mr_B));
+		 
+		statemachine.raiseBack();
+		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

@@ -1,80 +1,91 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.historywithoutinitialstep.HistoryWithoutInitialStepStatemachine;
-import org.yakindu.scr.historywithoutinitialstep.HistoryWithoutInitialStepStatemachine.State;
-/**
- *  Unit TestCase for HistoryWithoutInitialStep
- */
-@SuppressWarnings("all")
-public class HistoryWithoutInitialStepTest {
-
-	private HistoryWithoutInitialStepStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new HistoryWithoutInitialStepStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testenterThroughInitialEntry() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseToB();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
-		statemachine.raiseNext();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
-	}
-	@Test
-	public void testenterCThroughHistory() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseToB();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
-		statemachine.raiseToA();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseToHistory();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
-	}
-	@Test
-	public void testenterDThroughHistory() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseToB();
-		statemachine.runCycle();
-		statemachine.raiseNext();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
-		statemachine.raiseToA();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseToHistory();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.historywithoutinitialstep.HistoryWithoutInitialStepStatemachine;
+import org.yakindu.scr.historywithoutinitialstep.HistoryWithoutInitialStepStatemachine.State;
+
+/**
+ * Unit TestCase for HistoryWithoutInitialStep
+ */
+@SuppressWarnings("all")
+public class HistoryWithoutInitialStepTest {
+	private HistoryWithoutInitialStepStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new HistoryWithoutInitialStepStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testenterThroughInitialEntry() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseToB();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
+		 
+		statemachine.raiseNext();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
+		 
+	}
+	@Test
+	public void testenterCThroughHistory() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseToB();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
+		 
+		statemachine.raiseToA();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseToHistory();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
+		 
+	}
+	@Test
+	public void testenterDThroughHistory() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseToB();
+		statemachine.runCycle();
+		statemachine.raiseNext();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
+		 
+		statemachine.raiseToA();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseToHistory();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
+		 
+	}
+}

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

@@ -1,47 +1,49 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.ineventlifecycle.InEventLifeCycleStatemachine;
-import org.yakindu.scr.ineventlifecycle.InEventLifeCycleStatemachine.State;
-/**
- *  Unit TestCase for InEventLifeCycle
- */
-@SuppressWarnings("all")
-public class InEventLifeCycleTest {
-
-	private InEventLifeCycleStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new InEventLifeCycleStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testeventLifeCycle() {
-		statemachine.enter();
-		statemachine.raiseE();
-		assertTrue(statemachine.getI() == 0l);
-		statemachine.runCycle();
-		assertTrue(statemachine.getI() == 1l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.ineventlifecycle.InEventLifeCycleStatemachine;
+import org.yakindu.scr.ineventlifecycle.InEventLifeCycleStatemachine.State;
+
+/**
+ * Unit TestCase for InEventLifeCycle
+ */
+@SuppressWarnings("all")
+public class InEventLifeCycleTest {
+	private InEventLifeCycleStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new InEventLifeCycleStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testeventLifeCycle() {
+		statemachine.enter();
+		statemachine.raiseE();
+		assertTrue(statemachine.getI() == 0l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.getI() == 1l);
+		 
+	}
+}

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

@@ -1,65 +1,85 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.integerexpressions.IntegerExpressionsStatemachine;
-import org.yakindu.scr.integerexpressions.IntegerExpressionsStatemachine.State;
-/**
- *  Unit TestCase for IntegerExpressions
- */
-@SuppressWarnings("all")
-public class IntegerExpressionsTest {
-
-	private IntegerExpressionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new IntegerExpressionsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testintegerExpressions() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		assertTrue(statemachine.getMyInt1() == 10l);
-		assertTrue(statemachine.getMyInt2() == 5l);
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.getLess() == false);
-		assertTrue(statemachine.getGreater() == true);
-		assertTrue(statemachine.getEqualOrLess() == false);
-		assertTrue(statemachine.getEqualOrGreater() == true);
-		assertTrue(statemachine.getEqual() == false);
-		assertTrue(statemachine.getNotEqual() == true);
-		assertTrue(statemachine.getPlus() == 15l);
-		assertTrue(statemachine.getMinus() == 5l);
-		assertTrue(statemachine.getMultiply() == 50l);
-		assertTrue(statemachine.getDivision() == 2l);
-		assertTrue(statemachine.getModulo() == 0l);
-		assertTrue(statemachine.getNegat() == -10l);
-		assertTrue(statemachine.getMultiAssign() == 20l);
-		assertTrue(statemachine.getDivAssign() == 2l);
-		assertTrue(statemachine.getPlusAssign() == 12l);
-		assertTrue(statemachine.getMinusAssign() == -8l);
-		assertTrue(statemachine.getModuloAssign() == 0l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.integerexpressions.IntegerExpressionsStatemachine;
+import org.yakindu.scr.integerexpressions.IntegerExpressionsStatemachine.State;
+
+/**
+ * Unit TestCase for IntegerExpressions
+ */
+@SuppressWarnings("all")
+public class IntegerExpressionsTest {
+	private IntegerExpressionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new IntegerExpressionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testintegerExpressions() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_StateA));
+		 
+		assertTrue(statemachine.getMyInt1() == 10l);
+		 
+		assertTrue(statemachine.getMyInt2() == 5l);
+		 
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.getLess() == false);
+		 
+		assertTrue(statemachine.getGreater() == true);
+		 
+		assertTrue(statemachine.getEqualOrLess() == false);
+		 
+		assertTrue(statemachine.getEqualOrGreater() == true);
+		 
+		assertTrue(statemachine.getEqual() == false);
+		 
+		assertTrue(statemachine.getNotEqual() == true);
+		 
+		assertTrue(statemachine.getPlus() == 15l);
+		 
+		assertTrue(statemachine.getMinus() == 5l);
+		 
+		assertTrue(statemachine.getMultiply() == 50l);
+		 
+		assertTrue(statemachine.getDivision() == 2l);
+		 
+		assertTrue(statemachine.getModulo() == 0l);
+		 
+		assertTrue(statemachine.getNegat() == - 10l );
+		 
+		assertTrue(statemachine.getMultiAssign() == 20l);
+		 
+		assertTrue(statemachine.getDivAssign() == 2l);
+		 
+		assertTrue(statemachine.getPlusAssign() == 12l);
+		 
+		assertTrue(statemachine.getMinusAssign() == - 8l );
+		 
+		assertTrue(statemachine.getModuloAssign() == 0l);
+		 
+	}
+}

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

@@ -1,59 +1,69 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.internaleventlifecycle.InternalEventLifeCycleStatemachine;
-import org.yakindu.scr.internaleventlifecycle.InternalEventLifeCycleStatemachine.State;
-/**
- *  Unit TestCase for InternalEventLifeCycle
- */
-@SuppressWarnings("all")
-public class InternalEventLifeCycleTest {
-
-	private InternalEventLifeCycleStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new InternalEventLifeCycleStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testInternalEventLifeCycleTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.r1_A));
-		assertTrue(statemachine.isStateActive(State.r2_C));
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r1_A));
-		assertTrue(statemachine.isStateActive(State.r2_D));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r1_A));
-		assertTrue(statemachine.isStateActive(State.r2_D));
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r1_A));
-		assertTrue(statemachine.isStateActive(State.r2_C));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r1_A));
-		assertTrue(statemachine.isStateActive(State.r2_C));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.internaleventlifecycle.InternalEventLifeCycleStatemachine;
+import org.yakindu.scr.internaleventlifecycle.InternalEventLifeCycleStatemachine.State;
+
+/**
+ * Unit TestCase for InternalEventLifeCycle
+ */
+@SuppressWarnings("all")
+public class InternalEventLifeCycleTest {
+	private InternalEventLifeCycleStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new InternalEventLifeCycleStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testInternalEventLifeCycleTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.r1_A));
+		 
+		assertTrue(statemachine.isStateActive(State.r2_C));
+		 
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.r1_A));
+		 
+		assertTrue(statemachine.isStateActive(State.r2_D));
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.r1_A));
+		 
+		assertTrue(statemachine.isStateActive(State.r2_D));
+		 
+		statemachine.raiseF();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.r1_A));
+		 
+		assertTrue(statemachine.isStateActive(State.r2_C));
+		 
+		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

@@ -1,46 +1,48 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.localreactions.LocalReactionsStatemachine;
-import org.yakindu.scr.localreactions.LocalReactionsStatemachine.State;
-/**
- *  Unit TestCase for LocalReactions
- */
-@SuppressWarnings("all")
-public class LocalReactionsTest {
-
-	private LocalReactionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new LocalReactionsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testLocalReactionsTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();
-		assertTrue(statemachine.getX() == 1l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.localreactions.LocalReactionsStatemachine;
+import org.yakindu.scr.localreactions.LocalReactionsStatemachine.State;
+
+/**
+ * Unit TestCase for LocalReactions
+ */
+@SuppressWarnings("all")
+public class LocalReactionsTest {
+	private LocalReactionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new LocalReactionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testLocalReactionsTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.getX() == 1l);
+		 
+	}
+}

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

@@ -1,46 +1,46 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.logicaland.LogicalAndStatemachine;
-import org.yakindu.scr.logicaland.LogicalAndStatemachine.State;
-/**
- *  Unit TestCase for LogicalAnd
- */
-@SuppressWarnings("all")
-public class LogicalAndTestsTest {
-
-	private LogicalAndStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new LogicalAndStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testoperandEvaluationOrder() {
-		statemachine.enter();
-		statemachine.runCycle();
-		assertTrue("logical and expression was executed in wrong order...",
-				statemachine.getX() == 4l && statemachine.getB());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.logicaland.LogicalAndStatemachine;
+import org.yakindu.scr.logicaland.LogicalAndStatemachine.State;
+
+/**
+ * Unit TestCase for LogicalAnd
+ */
+@SuppressWarnings("all")
+public class LogicalAndTestsTest {
+	private LogicalAndStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new LogicalAndStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testoperandEvaluationOrder() {
+		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

@@ -1,46 +1,46 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.logicalor.LogicalOrStatemachine;
-import org.yakindu.scr.logicalor.LogicalOrStatemachine.State;
-/**
- *  Unit TestCase for LogicalOr
- */
-@SuppressWarnings("all")
-public class LogicalOrTestsTest {
-
-	private LogicalOrStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new LogicalOrStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testoperandEvaluationOrder() {
-		statemachine.enter();
-		statemachine.runCycle();
-		assertTrue("logical or expression was executed in wrong order...",
-				statemachine.getX() == 4l && statemachine.getB());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.logicalor.LogicalOrStatemachine;
+import org.yakindu.scr.logicalor.LogicalOrStatemachine.State;
+
+/**
+ * Unit TestCase for LogicalOr
+ */
+@SuppressWarnings("all")
+public class LogicalOrTestsTest {
+	private LogicalOrStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new LogicalOrStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testoperandEvaluationOrder() {
+		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

@@ -1,51 +1,52 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.namedinterfaceaccess.NamedInterfaceAccessStatemachine;
-import org.yakindu.scr.namedinterfaceaccess.NamedInterfaceAccessStatemachine.State;
-/**
- *  Unit TestCase for NamedInterfaceAccess
- */
-@SuppressWarnings("all")
-public class NamedInterfaceAccessTest {
-
-	private NamedInterfaceAccessStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new NamedInterfaceAccessStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testSafeOpenSuccess() {
-		statemachine.enter();
-		statemachine.runCycle();
-		statemachine.getSCIUser().raiseNumberPressed(3l);
-		statemachine.runCycle();
-		statemachine.getSCIUser().raiseNumberPressed(7l);
-		statemachine.runCycle();
-		statemachine.getSCIUser().raiseNumberPressed(5l);
-		statemachine.runCycle();
-		assertTrue(statemachine.getSCISafe().isRaisedOpen());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.namedinterfaceaccess.NamedInterfaceAccessStatemachine;
+import org.yakindu.scr.namedinterfaceaccess.NamedInterfaceAccessStatemachine.State;
+
+/**
+ * Unit TestCase for NamedInterfaceAccess
+ */
+@SuppressWarnings("all")
+public class NamedInterfaceAccessTest {
+	private NamedInterfaceAccessStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new NamedInterfaceAccessStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testSafeOpenSuccess() {
+		statemachine.enter();
+		statemachine.runCycle();
+		statemachine.getSCIUser().raiseNumberPressed(3l);
+		statemachine.runCycle();
+		statemachine.getSCIUser().raiseNumberPressed(7l);
+		statemachine.runCycle();
+		statemachine.getSCIUser().raiseNumberPressed(5l);
+		statemachine.runCycle();
+		assertTrue(statemachine.getSCISafe().isRaisedOpen());
+		 
+	}
+}

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

@@ -1,46 +1,48 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.nullcheck.NullCheckStatemachine;
-import org.yakindu.scr.nullcheck.NullCheckStatemachine.State;
-/**
- *  Unit TestCase for NullCheck
- */
-@SuppressWarnings("all")
-public class NullCheckTest {
-
-	private NullCheckStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new NullCheckStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testSimpleNullCheckTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.nullcheck.NullCheckStatemachine;
+import org.yakindu.scr.nullcheck.NullCheckStatemachine.State;
+
+/**
+ * Unit TestCase for NullCheck
+ */
+@SuppressWarnings("all")
+public class NullCheckTest {
+	private NullCheckStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new NullCheckStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testSimpleNullCheckTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		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/tests/OperationsTest.java

@@ -0,0 +1,162 @@
+/**
+* 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.tests;
+
+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.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+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 OperationsTest {
+	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);
+		 
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		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));
+		 
+		verify(internalMock, atLeastOnce()).internalOperation3();
+		 
+		ArgumentCaptor<Double> doubleCaptureinternalOperation3a_9_0 = forClass(Double.class);
+		verify(internalMock, atLeastOnce()).internalOperation3a(doubleCaptureinternalOperation3a_9_0.capture());
+		 
+		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));
+		 
+		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<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();
+		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));
+		 
+		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));
+		 
+		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));
+		 
+		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(""));
+		 
+		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));
+		 
+		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));
+		 
+		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));
+		 
+		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(""));
+		 
+	}
+}

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

@@ -0,0 +1,62 @@
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.operationswithoutbraces.OperationsWithoutBracesStatemachine;
+import org.yakindu.scr.operationswithoutbraces.OperationsWithoutBracesStatemachine.State;
+
+/**
+ * Unit TestCase for OperationsWithoutBraces
+ */
+@SuppressWarnings("all")
+public class OperationsWithoutBracesTest {
+	private OperationsWithoutBracesStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new OperationsWithoutBracesStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testOperationsWithoutBracesTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		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.another_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

@@ -1,69 +1,73 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.outeventlifecycle.OutEventLifeCycleStatemachine;
-import org.yakindu.scr.outeventlifecycle.OutEventLifeCycleStatemachine.State;
-/**
- *  Unit TestCase for OutEventLifeCycle
- */
-@SuppressWarnings("all")
-public class OutEventLifeCycleTest {
-
-	private OutEventLifeCycleStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new OutEventLifeCycleStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testavailableAfterCycle() {
-		statemachine.enter();
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.isRaisedF());
-	}
-	@Test
-	public void testavailableWithinCycle() {
-		statemachine.enter();
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.getF_available_in_cycle());
-	}
-	@Test
-	public void testunvailableWithin2ndCycle() {
-		statemachine.enter();
-		statemachine.raiseE();
-		statemachine.runCycle();
-		statemachine.runCycle();
-		assertTrue(!statemachine.getF_available_in_next_cycle());
-	}
-	@Test
-	public void testunvailableAfter2ndCycle() {
-		statemachine.enter();
-		statemachine.raiseE();
-		statemachine.runCycle();
-		statemachine.runCycle();
-		assertTrue(!statemachine.isRaisedF());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.outeventlifecycle.OutEventLifeCycleStatemachine;
+import org.yakindu.scr.outeventlifecycle.OutEventLifeCycleStatemachine.State;
+
+/**
+ * Unit TestCase for OutEventLifeCycle
+ */
+@SuppressWarnings("all")
+public class OutEventLifeCycleTest {
+	private OutEventLifeCycleStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new OutEventLifeCycleStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testavailableAfterCycle() {
+		statemachine.enter();
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.isRaisedF());
+		 
+	}
+	@Test
+	public void testavailableWithinCycle() {
+		statemachine.enter();
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.getF_available_in_cycle());
+		 
+	}
+	@Test
+	public void testunvailableWithin2ndCycle() {
+		statemachine.enter();
+		statemachine.raiseE();
+		statemachine.runCycle();
+		statemachine.runCycle();
+		assertTrue(!statemachine.getF_available_in_next_cycle());
+		 
+	}
+	@Test
+	public void testunvailableAfter2ndCycle() {
+		statemachine.enter();
+		statemachine.raiseE();
+		statemachine.runCycle();
+		statemachine.runCycle();
+		assertTrue(!statemachine.isRaisedF());
+		 
+	}
+}

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

@@ -1,45 +1,47 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.parenthesis.ParenthesisStatemachine;
-import org.yakindu.scr.parenthesis.ParenthesisStatemachine.State;
-/**
- *  Unit TestCase for Parenthesis
- */
-@SuppressWarnings("all")
-public class ParenthesisTest {
-
-	private ParenthesisStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ParenthesisStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testsimple() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.mainRegion_A));
-		assertTrue(statemachine.getErg() == 8l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.parenthesis.ParenthesisStatemachine;
+import org.yakindu.scr.parenthesis.ParenthesisStatemachine.State;
+
+/**
+ * Unit TestCase for Parenthesis
+ */
+@SuppressWarnings("all")
+public class ParenthesisTest {
+	private ParenthesisStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ParenthesisStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testsimple() {
+		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

@@ -1,95 +1,110 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.performancetest.PerformanceTestStatemachine;
-import org.yakindu.scr.performancetest.PerformanceTestStatemachine.State;
-import org.yakindu.scr.TimerService;
-/**
- *  Unit TestCase for PerformanceTest
- */
-@SuppressWarnings("all")
-public class PerformanceTestsTest {
-
-	private PerformanceTestStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new PerformanceTestStatemachine();
-		statemachine.setTimer(new TimerService());
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testtest_100_000() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.mr_A));
-		while (statemachine.getC() < 100000l) {
-			if (statemachine.isStateActive(State.mr_A)) {
-				statemachine.raiseE1();;
-			} else {
-				if (statemachine.getC() % 2l == 0l) {
-					statemachine.raiseE2();;
-				} else {
-					statemachine.raiseE3();;
-				} ;
-			}
-			statemachine.runCycle();
-		}
-		assertTrue(statemachine.getA() > 2l);
-	}
-	@Test
-	public void testtest_1_000_000() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.mr_A));
-		while (statemachine.getC() < 1000000l) {
-			if (statemachine.isStateActive(State.mr_A)) {
-				statemachine.raiseE1();;
-			} else {
-				if (statemachine.getC() % 2l == 0l) {
-					statemachine.raiseE2();;
-				} else {
-					statemachine.raiseE3();;
-				} ;
-			}
-			statemachine.runCycle();
-		}
-		assertTrue(statemachine.getA() > 2l);
-	}
-	@Test
-	public void testtest_10_000_000() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.mr_A));
-		while (statemachine.getC() < 10000000l) {
-			if (statemachine.isStateActive(State.mr_A)) {
-				statemachine.raiseE1();;
-			} else {
-				if (statemachine.getC() % 2l == 0l) {
-					statemachine.raiseE2();;
-				} else {
-					statemachine.raiseE3();;
-				} ;
-			}
-			statemachine.runCycle();
-		}
-		assertTrue(statemachine.getA() > 2l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.performancetest.PerformanceTestStatemachine;
+import org.yakindu.scr.performancetest.PerformanceTestStatemachine.State;
+import org.yakindu.scr.TimerService;
+
+/**
+ * Unit TestCase for PerformanceTest
+ */
+@SuppressWarnings("all")
+public class PerformanceTestsTest {
+	private PerformanceTestStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new PerformanceTestStatemachine();
+		statemachine.setTimer(new TimerService());
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testtest_100_000() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.mr_A));
+		 
+		while (statemachine.getC() < 100000l) {
+			if (statemachine.isStateActive(State.mr_A)) {
+						statemachine.raiseE1();;
+					  }
+					else {
+						if (statemachine.getC()%2l == 0l) {
+									statemachine.raiseE2();;
+								  }
+								else {
+									statemachine.raiseE3();;
+								}
+						;
+					}
+			statemachine.runCycle();
+		}
+		assertTrue(statemachine.getA() > 2l);
+		 
+	}
+	@Test
+	public void testtest_1_000_000() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.mr_A));
+		 
+		while (statemachine.getC() < 1000000l) {
+			if (statemachine.isStateActive(State.mr_A)) {
+						statemachine.raiseE1();;
+					  }
+					else {
+						if (statemachine.getC()%2l == 0l) {
+									statemachine.raiseE2();;
+								  }
+								else {
+									statemachine.raiseE3();;
+								}
+						;
+					}
+			statemachine.runCycle();
+		}
+		assertTrue(statemachine.getA() > 2l);
+		 
+	}
+	@Test
+	public void testtest_10_000_000() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.mr_A));
+		 
+		while (statemachine.getC() < 10000000l) {
+			if (statemachine.isStateActive(State.mr_A)) {
+						statemachine.raiseE1();;
+					  }
+					else {
+						if (statemachine.getC()%2l == 0l) {
+									statemachine.raiseE2();;
+								  }
+								else {
+									statemachine.raiseE3();;
+								}
+						;
+					}
+			statemachine.runCycle();
+		}
+		assertTrue(statemachine.getA() > 2l);
+		 
+	}
+}

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

@@ -1,56 +1,61 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.priorityvalues.PriorityValuesStatemachine;
-import org.yakindu.scr.priorityvalues.PriorityValuesStatemachine.State;
-/**
- *  Unit TestCase for PriorityValues
- */
-@SuppressWarnings("all")
-public class PriorityValuesTest {
-
-	private PriorityValuesStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new PriorityValuesStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testtransitionPriority() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_C));
-	}
-	@Test
-	public void testregionPriority() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.someRegion_A));
-		statemachine.raiseEvent2();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.someRegion_B));
-		assertTrue(!statemachine.isStateActive(State.main_region_E));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.priorityvalues.PriorityValuesStatemachine;
+import org.yakindu.scr.priorityvalues.PriorityValuesStatemachine.State;
+
+/**
+ * Unit TestCase for PriorityValues
+ */
+@SuppressWarnings("all")
+public class PriorityValuesTest {
+	private PriorityValuesStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new PriorityValuesStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testtransitionPriority() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseEvent1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_C));
+		 
+	}
+	@Test
+	public void testregionPriority() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.someRegion_A));
+		 
+		statemachine.raiseEvent2();
+		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

@@ -1,50 +1,54 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.raiseevent.RaiseEventStatemachine;
-import org.yakindu.scr.raiseevent.RaiseEventStatemachine.State;
-/**
- *  Unit TestCase for RaiseEvent
- */
-@SuppressWarnings("all")
-public class RaiseEventTest {
-
-	private RaiseEventStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new RaiseEventStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testraiseEvent() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.second_region_SateA));
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		statemachine.raiseE2();
-		statemachine.runCycle();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.second_region_StateB));
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.raiseevent.RaiseEventStatemachine;
+import org.yakindu.scr.raiseevent.RaiseEventStatemachine.State;
+
+/**
+ * Unit TestCase for RaiseEvent
+ */
+@SuppressWarnings("all")
+public class RaiseEventTest {
+	private RaiseEventStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new RaiseEventStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testraiseEvent() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.second_region_SateA));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_StateA));
+		 
+		statemachine.raiseE2();
+		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

@@ -1,62 +1,80 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.readonlyvariable.ReadOnlyVariableStatemachine;
-import org.yakindu.scr.readonlyvariable.ReadOnlyVariableStatemachine.State;
-/**
- *  Unit TestCase for ReadOnlyVariable
- */
-@SuppressWarnings("all")
-public class ReadOnlyVariableTest {
-
-	private ReadOnlyVariableStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ReadOnlyVariableStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testReadOnlyVariableTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		assertTrue(statemachine.getMyInt() == 0l);
-		assertTrue(statemachine.getMyString().equals("testString"));
-		assertTrue(statemachine.getMyBool() == true);
-		assertTrue(statemachine.getMyReal() == 1.1);
-		assertTrue(statemachine.getSCIA().getMyInt() == 0l);
-		assertTrue(statemachine.getSCIA().getMyString().equals("testString"));
-		assertTrue(statemachine.getSCIA().getMyBool() == true);
-		assertTrue(statemachine.getSCIA().getMyReal() == 1.1);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		assertTrue(statemachine.getMyInt() == 100l);
-		assertTrue(statemachine.getMyString().equals("fail"));
-		assertTrue(statemachine.getMyBool() == false);
-		assertTrue(statemachine.getMyReal() == 6.6);
-		assertTrue(statemachine.getSCIA().getMyInt() == 200l);
-		assertTrue(statemachine.getSCIA().getMyString().equals("A_fail"));
-		assertTrue(statemachine.getSCIA().getMyBool() == false);
-		assertTrue(statemachine.getSCIA().getMyReal() == 7.7);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.readonlyvariable.ReadOnlyVariableStatemachine;
+import org.yakindu.scr.readonlyvariable.ReadOnlyVariableStatemachine.State;
+
+/**
+ * Unit TestCase for ReadOnlyVariable
+ */
+@SuppressWarnings("all")
+public class ReadOnlyVariableTest {
+	private ReadOnlyVariableStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ReadOnlyVariableStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testReadOnlyVariableTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_StateA));
+		 
+		assertTrue(statemachine.getMyInt() == 0l);
+		 
+		assertTrue(statemachine.getMyString().equals("testString"));
+		 
+		assertTrue(statemachine.getMyBool() == true);
+		 
+		assertTrue(statemachine.getMyReal() == 1.1);
+		 
+		assertTrue(statemachine.getSCIA().getMyInt() == 0l);
+		 
+		assertTrue(statemachine.getSCIA().getMyString().equals("testString"));
+		 
+		assertTrue(statemachine.getSCIA().getMyBool() == true);
+		 
+		assertTrue(statemachine.getSCIA().getMyReal() == 1.1);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_StateB));
+		 
+		assertTrue(statemachine.getMyInt() == 100l);
+		 
+		assertTrue(statemachine.getMyString().equals("fail"));
+		 
+		assertTrue(statemachine.getMyBool() == false);
+		 
+		assertTrue(statemachine.getMyReal() == 6.6);
+		 
+		assertTrue(statemachine.getSCIA().getMyInt() == 200l);
+		 
+		assertTrue(statemachine.getSCIA().getMyString().equals("A_fail"));
+		 
+		assertTrue(statemachine.getSCIA().getMyBool() == false);
+		 
+		assertTrue(statemachine.getSCIA().getMyReal() == 7.7);
+		 
+	}
+}

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

@@ -1,52 +1,57 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.samenamedifferentregion.SameNameDifferentRegionStatemachine;
-import org.yakindu.scr.samenamedifferentregion.SameNameDifferentRegionStatemachine.State;
-/**
- *  Unit TestCase for SameNameDifferentRegion
- */
-@SuppressWarnings("all")
-public class SameNameDifferentRegionTest {
-
-	private SameNameDifferentRegionStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new SameNameDifferentRegionStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testsameNameDifferenRegionTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		assertTrue(statemachine.isStateActive(State.main_region_StateB_r1_StateA));
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		assertTrue(statemachine.isStateActive(State.main_region_StateB_r1_StateB));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.samenamedifferentregion.SameNameDifferentRegionStatemachine;
+import org.yakindu.scr.samenamedifferentregion.SameNameDifferentRegionStatemachine.State;
+
+/**
+ * Unit TestCase for SameNameDifferentRegion
+ */
+@SuppressWarnings("all")
+public class SameNameDifferentRegionTest {
+	private SameNameDifferentRegionStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new SameNameDifferentRegionStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testsameNameDifferenRegionTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_StateA));
+		 
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_StateB));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_StateB_r1_StateA));
+		 
+		statemachine.raiseE1();
+		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

@@ -1,76 +1,85 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.shallowhistory.ShallowHistoryStatemachine;
-import org.yakindu.scr.shallowhistory.ShallowHistoryStatemachine.State;
-/**
- *  Unit TestCase for ShallowHistory
- */
-@SuppressWarnings("all")
-public class ShallowHistoryTest {
-
-	private ShallowHistoryStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ShallowHistoryStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testshallowHistoryTest() {
-		statemachine.enter();
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		statemachine.raiseEvent3();
-		statemachine.runCycle();
-		statemachine.raiseEvent5();
-		statemachine.runCycle();
-		statemachine.raiseEvent7();
-		statemachine.runCycle();
-		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
-		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
-		statemachine.raiseEvent6();
-		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();
-		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();
-		assertTrue(
-				!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
-		assertTrue(statemachine.isStateActive(State.mainRegion_State1));
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State6));
-		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
-		statemachine.raiseEvent5();
-		statemachine.runCycle();
-		assertTrue(!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State6));
-		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.shallowhistory.ShallowHistoryStatemachine;
+import org.yakindu.scr.shallowhistory.ShallowHistoryStatemachine.State;
+
+/**
+ * Unit TestCase for ShallowHistory
+ */
+@SuppressWarnings("all")
+public class ShallowHistoryTest {
+	private ShallowHistoryStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ShallowHistoryStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testshallowHistoryTest() {
+		statemachine.enter();
+		statemachine.raiseEvent1();
+		statemachine.runCycle();
+		statemachine.raiseEvent3();
+		statemachine.runCycle();
+		statemachine.raiseEvent5();
+		statemachine.runCycle();
+		statemachine.raiseEvent7();
+		statemachine.runCycle();
+		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
+		 
+		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		 
+		statemachine.raiseEvent6();
+		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();
+		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();
+		assertTrue(!statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		 
+		assertTrue(statemachine.isStateActive(State.mainRegion_State1));
+		 
+		statemachine.raiseEvent1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.mainRegion_State2__region0_State4__region0_State6));
+		 
+		assertTrue(!statemachine.isStateActive(State.mainRegion_State1));
+		 
+		statemachine.raiseEvent5();
+		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

@@ -1,88 +1,105 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.shallowhistorywithdeepentry.ShallowHistoryWithDeepEntryStatemachine;
-import org.yakindu.scr.shallowhistorywithdeepentry.ShallowHistoryWithDeepEntryStatemachine.State;
-/**
- *  Unit TestCase for ShallowHistoryWithDeepEntry
- */
-@SuppressWarnings("all")
-public class ShallowHistoryWithDeepEntryTest {
-
-	private ShallowHistoryWithDeepEntryStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ShallowHistoryWithDeepEntryStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testnoDeepEntryWithinHistory() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_Y));
-		statemachine.raiseToZ();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_A));
-		statemachine.raiseToY();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Y));
-		statemachine.raiseToZ();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_A));
-	}
-	@Test
-	public void testdeepEntryWithinHistory() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_Y));
-		statemachine.raiseToZ();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_A));
-		statemachine.raiseToC();
-		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();
-		assertTrue(statemachine.isStateActive(State.main_region_Y));
-		statemachine.raiseToZ();
-		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();
-		assertTrue(statemachine.isStateActive(State.main_region_Y));
-		statemachine.raiseToC();
-		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();
-		assertTrue(statemachine.isStateActive(State.main_region_Y));
-		statemachine.raiseToZ();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B__region0_C));
-		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_B));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.shallowhistorywithdeepentry.ShallowHistoryWithDeepEntryStatemachine;
+import org.yakindu.scr.shallowhistorywithdeepentry.ShallowHistoryWithDeepEntryStatemachine.State;
+
+/**
+ * Unit TestCase for ShallowHistoryWithDeepEntry
+ */
+@SuppressWarnings("all")
+public class ShallowHistoryWithDeepEntryTest {
+	private ShallowHistoryWithDeepEntryStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ShallowHistoryWithDeepEntryStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testnoDeepEntryWithinHistory() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_Y));
+		 
+		statemachine.raiseToZ();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_A));
+		 
+		statemachine.raiseToY();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Y));
+		 
+		statemachine.raiseToZ();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_A));
+		 
+	}
+	@Test
+	public void testdeepEntryWithinHistory() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_Y));
+		 
+		statemachine.raiseToZ();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Z__region0_A));
+		 
+		statemachine.raiseToC();
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_Y));
+		 
+		statemachine.raiseToZ();
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_Y));
+		 
+		statemachine.raiseToC();
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_Y));
+		 
+		statemachine.raiseToZ();
+		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

@@ -1,50 +1,54 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.simpleevent.SimpleEventStatemachine;
-import org.yakindu.scr.simpleevent.SimpleEventStatemachine.State;
-/**
- *  Unit TestCase for SimpleEvent
- */
-@SuppressWarnings("all")
-public class SimpleEventTest {
-
-	private SimpleEventStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new SimpleEventStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testsimpleEventTest() {
-		statemachine.enter();
-		assertTrue("Expected A to be active", statemachine.isStateActive(State.main_region_A));
-		assertTrue(5l == 5l);
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		assertTrue("Expected B to be active", statemachine.isStateActive(State.main_region_B));
-		statemachine.runCycle();
-		assertTrue(!statemachine.isStateActive(State.main_region_B));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.simpleevent.SimpleEventStatemachine;
+import org.yakindu.scr.simpleevent.SimpleEventStatemachine.State;
+
+/**
+ * Unit TestCase for SimpleEvent
+ */
+@SuppressWarnings("all")
+public class SimpleEventTest {
+	private SimpleEventStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new SimpleEventStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testsimpleEventTest() {
+		statemachine.enter();
+		assertTrue("Expected A to be active",statemachine.isStateActive(State.main_region_A));
+		 
+		assertTrue(5l == 5l);
+		 
+		statemachine.raiseEvent1();
+		statemachine.runCycle();
+		assertTrue("Expected B to be active",statemachine.isStateActive(State.main_region_B));
+		 
+		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

@@ -1,50 +1,53 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.simplehierachy.SimpleHierachyStatemachine;
-import org.yakindu.scr.simplehierachy.SimpleHierachyStatemachine.State;
-/**
- *  Unit TestCase for SimpleHierachy
- */
-@SuppressWarnings("all")
-public class SimpleHierachyTest {
-
-	private SimpleHierachyStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new SimpleHierachyStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testsimpleHierachyTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseEvent1();
-		statemachine.raiseEvent1();
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		assertTrue(statemachine.isStateActive(State.main_region_B_subregion1_B1));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.simplehierachy.SimpleHierachyStatemachine;
+import org.yakindu.scr.simplehierachy.SimpleHierachyStatemachine.State;
+
+/**
+ * Unit TestCase for SimpleHierachy
+ */
+@SuppressWarnings("all")
+public class SimpleHierachyTest {
+	private SimpleHierachyStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new SimpleHierachyStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testsimpleHierachyTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseEvent1();
+		statemachine.raiseEvent1();
+		statemachine.raiseEvent1();
+		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

@@ -1,50 +1,54 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.stateisactive.StateIsActiveStatemachine;
-import org.yakindu.scr.stateisactive.StateIsActiveStatemachine.State;
-/**
- *  Unit TestCase for StateIsActive
- */
-@SuppressWarnings("all")
-public class StateIsActiveTest {
-
-	private StateIsActiveStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new StateIsActiveStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void teststateIsActive() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.r1_R1A));
-		assertTrue(statemachine.isStateActive(State.r2_R2A));
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.r1_R1B));
-		assertTrue(statemachine.isStateActive(State.r2_R2B));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.stateisactive.StateIsActiveStatemachine;
+import org.yakindu.scr.stateisactive.StateIsActiveStatemachine.State;
+
+/**
+ * Unit TestCase for StateIsActive
+ */
+@SuppressWarnings("all")
+public class StateIsActiveTest {
+	private StateIsActiveStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new StateIsActiveStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void teststateIsActive() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.r1_R1A));
+		 
+		assertTrue(statemachine.isStateActive(State.r2_R2A));
+		 
+		statemachine.raiseEvent1();
+		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

@@ -1,61 +1,65 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.statechartactive.StatechartActiveStatemachine;
-import org.yakindu.scr.statechartactive.StatechartActiveStatemachine.State;
-/**
- *  Unit TestCase for StatechartActive
- */
-@SuppressWarnings("all")
-public class StatechartActiveTest {
-
-	private StatechartActiveStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new StatechartActiveStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testinactiveBeforeEnter() {
-		assertTrue(!statemachine.isActive());
-	}
-	@Test
-	public void testactiveAfterEnter() {
-		statemachine.enter();
-		assertTrue(statemachine.isActive());
-	}
-	@Test
-	public void testinactiveAfterExit() {
-		statemachine.enter();
-		statemachine.exit();
-		assertTrue(!statemachine.isActive());
-	}
-	@Test
-	public void testactiveAfterReenter() {
-		statemachine.enter();
-		statemachine.exit();
-		statemachine.enter();
-		assertTrue(statemachine.isActive());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.statechartactive.StatechartActiveStatemachine;
+import org.yakindu.scr.statechartactive.StatechartActiveStatemachine.State;
+
+/**
+ * Unit TestCase for StatechartActive
+ */
+@SuppressWarnings("all")
+public class StatechartActiveTest {
+	private StatechartActiveStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new StatechartActiveStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testinactiveBeforeEnter() {
+		assertTrue(!statemachine.isActive());
+		 
+	}
+	@Test
+	public void testactiveAfterEnter() {
+		statemachine.enter();
+		assertTrue(statemachine.isActive());
+		 
+	}
+	@Test
+	public void testinactiveAfterExit() {
+		statemachine.enter();
+		statemachine.exit();
+		assertTrue(!statemachine.isActive());
+		 
+	}
+	@Test
+	public void testactiveAfterReenter() {
+		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

@@ -1,54 +1,62 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.statechartlocalreactions.StatechartLocalReactionsStatemachine;
-import org.yakindu.scr.statechartlocalreactions.StatechartLocalReactionsStatemachine.State;
-/**
- *  Unit TestCase for StatechartLocalReactions
- */
-@SuppressWarnings("all")
-public class StatechartLocalReactionsTest {
-
-	private StatechartLocalReactionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new StatechartLocalReactionsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void teststatechartLocalReactionsTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_S1));
-		assertTrue(statemachine.isStateActive(State.region2_a));
-		while (statemachine.getMyInt() < 10l) {
-			assertTrue(statemachine.isStateActive(State.region2_a));
-			if (statemachine.getMyInt() % 2l == 0l) {
-				assertTrue(statemachine.isStateActive(State.main_region_S1));;
-			} else {
-				assertTrue(statemachine.isStateActive(State.main_region_S2));;
-			}
-			statemachine.runCycle();
-		}
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.statechartlocalreactions.StatechartLocalReactionsStatemachine;
+import org.yakindu.scr.statechartlocalreactions.StatechartLocalReactionsStatemachine.State;
+
+/**
+ * Unit TestCase for StatechartLocalReactions
+ */
+@SuppressWarnings("all")
+public class StatechartLocalReactionsTest {
+	private StatechartLocalReactionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new StatechartLocalReactionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void teststatechartLocalReactionsTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_S1));
+		 
+		assertTrue(statemachine.isStateActive(State.region2_a));
+		 
+		while (statemachine.getMyInt() < 10l) {
+			assertTrue(statemachine.isStateActive(State.region2_a));
+			 
+			if (statemachine.getMyInt()%2l == 0l) {
+						assertTrue(statemachine.isStateActive(State.main_region_S1));
+						 
+						;
+					  }
+					else {
+						assertTrue(statemachine.isStateActive(State.main_region_S2));
+						 
+						;
+					}
+			statemachine.runCycle();
+		}
+	}
+}

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

@@ -1,46 +1,47 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.statechartkeywords.StatechartKeywordsStatemachine;
-import org.yakindu.scr.statechartkeywords.StatechartKeywordsStatemachine.State;
-import org.yakindu.scr.TimerService;
-/**
- *  Unit TestCase for StatechartKeywords
- */
-@SuppressWarnings("all")
-public class StatemachineKeywordsTest {
-
-	private StatechartKeywordsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new StatechartKeywordsStatemachine();
-		statemachine.setTimer(new TimerService());
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void teststatemachineKeywords() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_Timer));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.statechartkeywords.StatechartKeywordsStatemachine;
+import org.yakindu.scr.statechartkeywords.StatechartKeywordsStatemachine.State;
+import org.yakindu.scr.TimerService;
+
+/**
+ * Unit TestCase for StatechartKeywords
+ */
+@SuppressWarnings("all")
+public class StatemachineKeywordsTest {
+	private StatechartKeywordsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new StatechartKeywordsStatemachine();
+		statemachine.setTimer(new TimerService());
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void teststatemachineKeywords() {
+		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

@@ -1,45 +1,46 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.staticchoice.StaticChoiceStatemachine;
-import org.yakindu.scr.staticchoice.StaticChoiceStatemachine.State;
-/**
- *  Unit TestCase for StaticChoice
- */
-@SuppressWarnings("all")
-public class StaticChoiceTest {
-
-	private StaticChoiceStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new StaticChoiceStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testStaticChoiceTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_Start));
-		statemachine.runCycle();
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.staticchoice.StaticChoiceStatemachine;
+import org.yakindu.scr.staticchoice.StaticChoiceStatemachine.State;
+
+/**
+ * Unit TestCase for StaticChoice
+ */
+@SuppressWarnings("all")
+public class StaticChoiceTest {
+	private StaticChoiceStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new StaticChoiceStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testStaticChoiceTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_Start));
+		 
+		statemachine.runCycle();
+	}
+}

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

@@ -1,74 +1,97 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.stringexpressions.StringExpressionsStatemachine;
-import org.yakindu.scr.stringexpressions.StringExpressionsStatemachine.State;
-/**
- *  Unit TestCase for StringExpressions
- */
-@SuppressWarnings("all")
-public class StringExpressionsTest {
-
-	private StringExpressionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new StringExpressionsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testStringExpressionsTest() {
-		assertTrue(statemachine.getQuotedStringX().equals("\"X\""));
-		assertTrue(statemachine.getQuotedStringY().equals("\"Y\""));
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_AssignmentChecked));
-		statemachine.raiseE();
-		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();
-		assertTrue(statemachine.isStateActive(State.main_region_VarToConstCompareSucceeded));
-		assertTrue(statemachine.getGuardStringEqual());
-		assertTrue(statemachine.getGuardStringNotEqual());
-		assertTrue(statemachine.getStringVarEqual());
-		assertTrue(statemachine.getStringVarNotEqual());
-		statemachine.raiseE();
-		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();
-		assertTrue(statemachine.isStateActive(State.main_region_ConstToConstCompareSucceeded));
-		assertTrue(statemachine.getGuardStringEqual());
-		assertTrue(statemachine.getGuardStringNotEqual());
-		assertTrue(statemachine.getStringVarEqual());
-		assertTrue(statemachine.getStringVarNotEqual());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.stringexpressions.StringExpressionsStatemachine;
+import org.yakindu.scr.stringexpressions.StringExpressionsStatemachine.State;
+
+/**
+ * Unit TestCase for StringExpressions
+ */
+@SuppressWarnings("all")
+public class StringExpressionsTest {
+	private StringExpressionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new StringExpressionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testStringExpressionsTest() {
+		assertTrue(statemachine.getQuotedStringX().equals("\"X\""));
+		 
+		assertTrue(statemachine.getQuotedStringY().equals("\"Y\""));
+		 
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_AssignmentChecked));
+		 
+		statemachine.raiseE();
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_VarToConstCompareSucceeded));
+		 
+		assertTrue(statemachine.getGuardStringEqual());
+		 
+		assertTrue(statemachine.getGuardStringNotEqual());
+		 
+		assertTrue(statemachine.getStringVarEqual());
+		 
+		assertTrue(statemachine.getStringVarNotEqual());
+		 
+		statemachine.raiseE();
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_ConstToConstCompareSucceeded));
+		 
+		assertTrue(statemachine.getGuardStringEqual());
+		 
+		assertTrue(statemachine.getGuardStringNotEqual());
+		 
+		assertTrue(statemachine.getStringVarEqual());
+		 
+		assertTrue(statemachine.getStringVarNotEqual());
+		 
+	}
+}

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

@@ -1,62 +1,73 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.syncfork.SyncForkStatemachine;
-import org.yakindu.scr.syncfork.SyncForkStatemachine.State;
-/**
- *  Unit TestCase for SyncFork
- */
-@SuppressWarnings("all")
-public class SyncForkTest {
-
-	private SyncForkStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new SyncForkStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testsyncForkTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseF();
-		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();
-		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();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseF();
-		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));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.syncfork.SyncForkStatemachine;
+import org.yakindu.scr.syncfork.SyncForkStatemachine.State;
+
+/**
+ * Unit TestCase for SyncFork
+ */
+@SuppressWarnings("all")
+public class SyncForkTest {
+	private SyncForkStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new SyncForkStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testsyncForkTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseF();
+		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();
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseF();
+		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

@@ -1,119 +1,152 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.syncjoin.SyncJoinStatemachine;
-import org.yakindu.scr.syncjoin.SyncJoinStatemachine.State;
-/**
- *  Unit TestCase for SyncJoin
- */
-@SuppressWarnings("all")
-public class SyncJoinTest {
-
-	private SyncJoinStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new SyncJoinStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testsyncJoin_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();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
-		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
-		statemachine.raiseJc();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
-		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
-		statemachine.raiseJd();
-		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();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
-		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
-		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
-		statemachine.raiseJc();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
-		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
-		statemachine.raiseJd();
-		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();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-	}
-	@Test
-	public void testsyncJoin_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();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
-		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
-		statemachine.raiseJc();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
-		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
-		statemachine.raiseJd();
-		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();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
-		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
-		statemachine.raiseE();
-		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();
-		statemachine.raiseE();
-		statemachine.raiseF();
-		statemachine.runCycle();
-		statemachine.raiseJc();
-		statemachine.raiseJd();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		assertTrue(statemachine.getX() == 1l);
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.syncjoin.SyncJoinStatemachine;
+import org.yakindu.scr.syncjoin.SyncJoinStatemachine.State;
+
+/**
+ * Unit TestCase for SyncJoin
+ */
+@SuppressWarnings("all")
+public class SyncJoinTest {
+	private SyncJoinStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new SyncJoinStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testsyncJoin_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();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
+		 
+		statemachine.raiseJc();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
+		 
+		statemachine.raiseJd();
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D1));
+		 
+		statemachine.raiseF();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
+		 
+		statemachine.raiseJc();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C2));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
+		 
+		statemachine.raiseJd();
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+	}
+	@Test
+	public void testsyncJoin_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();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
+		 
+		statemachine.raiseJc();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
+		 
+		statemachine.raiseJd();
+		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();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C1));
+		 
+		assertTrue(statemachine.isStateActive(State.main_region_B_r2_D2));
+		 
+		statemachine.raiseE();
+		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();
+		statemachine.raiseE();
+		statemachine.raiseF();
+		statemachine.runCycle();
+		statemachine.raiseJc();
+		statemachine.raiseJd();
+		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

@@ -1,52 +1,51 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.timedtransitions.TimedTransitionsStatemachine;
-import org.yakindu.scr.timedtransitions.TimedTransitionsStatemachine.State;
-import org.yakindu.scr.TimerService;
-/**
- *  Unit TestCase for TimedTransitions
- */
-@SuppressWarnings("all")
-public class TimedTransitionsTest {
-
-	private TimedTransitionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new TimedTransitionsStatemachine();
-		statemachine.setTimer(new TimerService());
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testTimer01() {
-		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));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.timedtransitions.TimedTransitionsStatemachine;
+import org.yakindu.scr.timedtransitions.TimedTransitionsStatemachine.State;
+import org.yakindu.scr.TimerService;
+
+/**
+ * Unit TestCase for TimedTransitions
+ */
+@SuppressWarnings("all")
+public class TimedTransitionsTest {
+	private TimedTransitionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new TimedTransitionsStatemachine();
+		statemachine.setTimer(new TimerService());
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testTimer01() {
+		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

@@ -1,46 +1,48 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.transitionwithoutcondition.TransitionWithoutConditionStatemachine;
-import org.yakindu.scr.transitionwithoutcondition.TransitionWithoutConditionStatemachine.State;
-/**
- *  Unit TestCase for TransitionWithoutCondition
- */
-@SuppressWarnings("all")
-public class TransitionWithoutConditionTest {
-
-	private TransitionWithoutConditionStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new TransitionWithoutConditionStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testTransitionWithoutConditionTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.transitionwithoutcondition.TransitionWithoutConditionStatemachine;
+import org.yakindu.scr.transitionwithoutcondition.TransitionWithoutConditionStatemachine.State;
+
+/**
+ * Unit TestCase for TransitionWithoutCondition
+ */
+@SuppressWarnings("all")
+public class TransitionWithoutConditionTest {
+	private TransitionWithoutConditionStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new TransitionWithoutConditionStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testTransitionWithoutConditionTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		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

@@ -1,71 +1,75 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceStatemachine;
-import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceStatemachine.State;
-/**
- *  Unit TestCase for TriggerExpressionPrecedence
- */
-@SuppressWarnings("all")
-public class TriggerExpressionPrecedenceTest {
-
-	private TriggerExpressionPrecedenceStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new TriggerExpressionPrecedenceStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testunsatisfiedTriggerAndFGuardFalseOrFalse() {
-		statemachine.enter();
-		statemachine.setC1(false);
-		statemachine.setC2(false);
-		statemachine.runCycle();
-		assertTrue(!statemachine.getE1_transition());
-	}
-	@Test
-	public void testunsatisfiedTriggerAndFGuardTrueOrFalse() {
-		statemachine.enter();
-		statemachine.setC1(true);
-		statemachine.setC2(false);
-		statemachine.runCycle();
-		assertTrue(!statemachine.getE1_transition());
-	}
-	@Test
-	public void testunsatisfiedTriggerAndFGuardFalseOrTrue() {
-		statemachine.enter();
-		statemachine.setC1(false);
-		statemachine.setC2(true);
-		statemachine.runCycle();
-		assertTrue(!statemachine.getE1_transition());
-	}
-	@Test
-	public void testunsatisfiedTriggerAndFGuardTrueOrTrue() {
-		statemachine.enter();
-		statemachine.setC1(true);
-		statemachine.setC2(true);
-		statemachine.runCycle();
-		assertTrue(!statemachine.getE1_transition());
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceStatemachine;
+import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceStatemachine.State;
+
+/**
+ * Unit TestCase for TriggerExpressionPrecedence
+ */
+@SuppressWarnings("all")
+public class TriggerExpressionPrecedenceTest {
+	private TriggerExpressionPrecedenceStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new TriggerExpressionPrecedenceStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testunsatisfiedTriggerAndFGuardFalseOrFalse() {
+		statemachine.enter();
+		statemachine.setC1(false);
+		statemachine.setC2(false);
+		statemachine.runCycle();
+		assertTrue(!statemachine.getE1_transition());
+		 
+	}
+	@Test
+	public void testunsatisfiedTriggerAndFGuardTrueOrFalse() {
+		statemachine.enter();
+		statemachine.setC1(true);
+		statemachine.setC2(false);
+		statemachine.runCycle();
+		assertTrue(!statemachine.getE1_transition());
+		 
+	}
+	@Test
+	public void testunsatisfiedTriggerAndFGuardFalseOrTrue() {
+		statemachine.enter();
+		statemachine.setC1(false);
+		statemachine.setC2(true);
+		statemachine.runCycle();
+		assertTrue(!statemachine.getE1_transition());
+		 
+	}
+	@Test
+	public void testunsatisfiedTriggerAndFGuardTrueOrTrue() {
+		statemachine.enter();
+		statemachine.setC1(true);
+		statemachine.setC2(true);
+		statemachine.runCycle();
+		assertTrue(!statemachine.getE1_transition());
+		 
+	}
+}

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

@@ -1,75 +1,85 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.triggerguardexpressions.TriggerGuardExpressionsStatemachine;
-import org.yakindu.scr.triggerguardexpressions.TriggerGuardExpressionsStatemachine.State;
-/**
- *  Unit TestCase for TriggerGuardExpressions
- */
-@SuppressWarnings("all")
-public class TriggerGuardExpressionsTest {
-
-	private TriggerGuardExpressionsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new TriggerGuardExpressionsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testtrueGuard() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseE1();
-		statemachine.setB(true);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseE2();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseE1();
-		statemachine.raiseE2();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B));
-	}
-	@Test
-	public void testfalseGuard() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.setB(false);
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseE2();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseE1();
-		statemachine.raiseE2();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.triggerguardexpressions.TriggerGuardExpressionsStatemachine;
+import org.yakindu.scr.triggerguardexpressions.TriggerGuardExpressionsStatemachine.State;
+
+/**
+ * Unit TestCase for TriggerGuardExpressions
+ */
+@SuppressWarnings("all")
+public class TriggerGuardExpressionsTest {
+	private TriggerGuardExpressionsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new TriggerGuardExpressionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testtrueGuard() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseE1();
+		statemachine.setB(true);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseE1();
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B));
+		 
+	}
+	@Test
+	public void testfalseGuard() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.setB(false);
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		 
+		statemachine.raiseE1();
+		statemachine.raiseE2();
+		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

@@ -1,53 +1,59 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.typealias.TypeAliasStatemachine;
-import org.yakindu.scr.typealias.TypeAliasStatemachine.State;
-/**
- *  Unit TestCase for TypeAlias
- */
-@SuppressWarnings("all")
-public class TypeAliasTest {
-
-	private TypeAliasStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new TypeAliasStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testTypeAliasTest() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_Start));
-		assertTrue(statemachine.getMyVar() == 1l);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Mid));
-		assertTrue(statemachine.getMyString() == "TypeSystem");
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Mid2));
-		statemachine.raiseMyEvent();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_End));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.typealias.TypeAliasStatemachine;
+import org.yakindu.scr.typealias.TypeAliasStatemachine.State;
+
+/**
+ * Unit TestCase for TypeAlias
+ */
+@SuppressWarnings("all")
+public class TypeAliasTest {
+	private TypeAliasStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new TypeAliasStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testTypeAliasTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_Start));
+		 
+		assertTrue(statemachine.getMyVar() == 1l);
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Mid));
+		 
+		assertTrue(statemachine.getMyString().equals("TypeSystem"));
+		 
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Mid2));
+		 
+		statemachine.raiseMyEvent();
+		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

@@ -1,58 +1,67 @@
-/**
-* Copyright (c) 2016 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.After;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import org.yakindu.scr.valuedevents.ValuedEventsStatemachine;
-import org.yakindu.scr.valuedevents.ValuedEventsStatemachine.State;
-/**
- *  Unit TestCase for ValuedEvents
- */
-@SuppressWarnings("all")
-public class ValuedEventsTest {
-
-	private ValuedEventsStatemachine statemachine;
-
-	@Before
-	public void setUp() {
-		statemachine = new ValuedEventsStatemachine();
-		statemachine.init();
-	}
-
-	@After
-	public void tearDown() {
-		statemachine = null;
-	}
-
-	@Test
-	public void testvaluedEventsTest() {
-		statemachine.enter();
-		statemachine.runCycle();
-		assertTrue(statemachine.getMyString().equals("sct"));
-		statemachine.raiseIntegerEvent(23l);
-		statemachine.raiseBooleanEvent(false);
-		statemachine.raiseRealEvent(20l);
-		statemachine.raiseStringEvent("tool");
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.integer_region_D));
-		assertTrue(statemachine.isStateActive(State.string_region_D));
-		assertTrue(statemachine.isStateActive(State.boolean_region_D));
-		assertTrue(statemachine.isStateActive(State.real_region_D));
-		assertTrue(statemachine.getMyInt() == 23l);
-		assertTrue(statemachine.getMyBool() == false);
-		assertTrue(statemachine.getMyReal() == 20l);
-		assertTrue(statemachine.getMyString().equals("tool"));
-	}
-}
+/**
+* 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.tests;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.valuedevents.ValuedEventsStatemachine;
+import org.yakindu.scr.valuedevents.ValuedEventsStatemachine.State;
+
+/**
+ * Unit TestCase for ValuedEvents
+ */
+@SuppressWarnings("all")
+public class ValuedEventsTest {
+	private ValuedEventsStatemachine statemachine;	
+	
+	@Before
+	public void setUp() {
+		statemachine = new ValuedEventsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+	
+	@Test
+	public void testvaluedEventsTest() {
+		statemachine.enter();
+		statemachine.runCycle();
+		assertTrue(statemachine.getMyString().equals("sct"));
+		 
+		statemachine.raiseIntegerEvent(23l);
+		statemachine.raiseBooleanEvent(false);
+		statemachine.raiseRealEvent(20l);
+		statemachine.raiseStringEvent("tool");
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.integer_region_D));
+		 
+		assertTrue(statemachine.isStateActive(State.string_region_D));
+		 
+		assertTrue(statemachine.isStateActive(State.boolean_region_D));
+		 
+		assertTrue(statemachine.isStateActive(State.real_region_D));
+		 
+		assertTrue(statemachine.getMyInt() == 23l);
+		 
+		assertTrue(statemachine.getMyBool() == false);
+		 
+		assertTrue(statemachine.getMyReal() == 20l);
+		 
+		assertTrue(statemachine.getMyString().equals("tool"));
+		 
+	}
+}

test-plugins/org.yakindu.sct.test.models/tests/AllTests.sctunit

@@ -1,64 +1,69 @@
-testsuite AllTests {
-	AlwaysOncycle, 
-	AssignmentAsExpression,
-	BitExpressions, 
-	BooleanExpressions,
-	CastExpressions,
-	Choice, 
-	CKeywords,
-	ConditionalExpression,
-	ConstantsTests,
-	Declarations, 
-	DeepEntry,
-	DeepHistory,
-	DynamicChoice,
-	EmptyTransition, 
-	EnterState,
-	EntryChoice,
-	EntryExitSelfTransition,
-	EntryReactionAction,
-	ExitOnSelfTransition, 
-	ExitState,
-	FeatureCalls,
-	FinalState,
-	Guard, 
-	GuardedEntry, 
-	GuardedExit, 
-	HistoryWithExitPoint,
-	HistoryWithoutInitialStep,
-	InEventLifeCycle, 
-	IntegerExpressions, 
-	InternalEventLifeCycle,
-	LocalReactions,
-	LogicalAndTests, 
-	LogicalOrTests,
-	NamedInterfaceAccess,
-//	OperationsWithoutBraces,
-	OutEventLifeCycle,
-	Parenthesis,
-	PriorityValues,
-	RaiseEvent,
-	ReadOnlyVariable,
-	SameNameDifferentRegion, 
-	ShallowHistory, 	
-	ShallowHistoryWithDeepEntry, 	
-	SimpleEvent,
-	SimpleHierachy,
-	StatechartActive, 
-	StatechartLocalReactions,
-	StateIsActive, 
-	StaticChoice,
-	STextKeywordsInStatesAndRegions,
-	StringExpressions, 
-	SyncFork,
-	SyncJoin,
-	TransitionWithoutCondition,
-	TriggerGuardExpressions,
-	TriggerExpressionPrecedence,
-	ValuedEvents,
-	TypeAlias
-	//Add the following tests if sct unit Java and C++ generators
-	// support mock timer service generation
-	//StatemachineKeywords,
-	//TimedTransitions,
+package tests
+testsuite AllTests {
+	AlwaysOncycle, 
+	AssignmentAsExpression,
+	BitExpressions, 
+	BooleanExpressions,
+	CastExpressions,
+	Choice, 
+	CKeywords,
+	ConditionalExpression,
+	ConstantsTests,
+	ConstOnlyDefaultScope,
+	ConstOnlyInternalScope,
+	ConstOnlyNamedScope,
+	Declarations, 
+	DeepEntry,
+	DeepHistory,
+	DynamicChoice,
+	EmptyTransition, 
+	EnterState,
+	EntryChoice,
+	EntryExitSelfTransition,
+	EntryReactionAction,
+	ExitOnSelfTransition, 
+	ExitState,
+	FeatureCalls,
+	FinalState,
+	Guard, 
+	GuardedEntry, 
+	GuardedExit, 
+	HistoryWithExitPoint,
+	HistoryWithoutInitialStep,
+	InEventLifeCycle, 
+	IntegerExpressions, 
+	InternalEventLifeCycle,
+	LocalReactions,
+	LogicalAndTests, 
+	LogicalOrTests,
+	NamedInterfaceAccess,
+	Operations,
+//	OperationsWithoutBraces,
+	OutEventLifeCycle,
+	Parenthesis,
+	PriorityValues,
+	RaiseEvent,
+	ReadOnlyVariable,
+	SameNameDifferentRegion, 
+	ShallowHistory, 	
+	ShallowHistoryWithDeepEntry, 	
+	SimpleEvent,
+	SimpleHierachy,
+	StatechartActive, 
+	StatechartLocalReactions,
+	StateIsActive, 
+	StaticChoice,
+	STextKeywordsInStatesAndRegions,
+	StringExpressions, 
+	SyncFork,
+	SyncJoin,
+	TransitionWithoutCondition,
+	TriggerGuardExpressions,
+	TriggerExpressionPrecedence,
+	ValuedEvents,
+	TypeAlias
+	//Add the following tests if sct unit Java and C++ generators
+	// support mock timer service generation
+	//StatemachineKeywords,
+	//TimedTransitions,
 } 

test-plugins/org.yakindu.sct.test.models/tests/AlwaysOncycle.sctunit

@@ -1,6 +1,7 @@
-testgroup AlwaysOncycle for statechart AlwaysOncycle {
+package tests
+testclass AlwaysOncycle for statechart AlwaysOncycle {
 
-	 test alwaysOncycleTest {
+	 operation alwaysOncycleTest (){
 	 	
 	 	enter
 		assert active (AlwaysOncycle.main_region.StateA)

test-plugins/org.yakindu.sct.test.models/tests/AssignmentAsExpression.sctunit

@@ -1,49 +1,49 @@
-
-testgroup AssignmentAsExpression for statechart AssignmentAsExpression{
-	
-	 
-	  test simpleAssignment{ 
-	  	enter
-	  	assert active(AssignmentAsExpression.main_region.Add)
-	  		  	
-	  	assert b == 5
-	  	assert a == 9	  	
-	   	
-	  	cycle
-	  	assert active(AssignmentAsExpression.main_region.Subtract) 
-	  	assert d == 6
-	  	
-	  	cycle
-	  	assert active(AssignmentAsExpression.main_region.Multiply) 
-	  	assert e == 15
-	  	
-	  	cycle
-	  	assert active(AssignmentAsExpression.main_region.Divide) 
-	  	assert g == 1	  	
-	  	
-	  	cycle
-	  	assert active(AssignmentAsExpression.main_region.Modulo)
-	  	assert i == 1
-
-	  	cycle
-	  	assert active(AssignmentAsExpression.main_region.Shift)
-		assert j == 16
-		assert k == 4
-		
-	  	cycle
-	  	assert active(AssignmentAsExpression.main_region.boolean_And)
-		assert l == 1
-
-	  	cycle
-	  	assert active(AssignmentAsExpression.main_region.boolean_Or)
-		assert p == 15
-		
-	  	cycle
-	  	assert active(AssignmentAsExpression.main_region.boolean_Xor)
-		assert u == 12		
-	  	
-	  	exit
-	  } 
-	 
-}
+package tests
+testclass AssignmentAsExpression for statechart AssignmentAsExpression{
+	
+	 
+	  operation simpleAssignment(){ 
+	  	enter
+	  	assert active(AssignmentAsExpression.main_region.Add)
+	  		  	
+	  	assert b == 5
+	  	assert a == 9	  	
+	   	
+	  	cycle
+	  	assert active(AssignmentAsExpression.main_region.Subtract) 
+	  	assert d == 6
+	  	
+	  	cycle
+	  	assert active(AssignmentAsExpression.main_region.Multiply) 
+	  	assert e == 15
+	  	
+	  	cycle
+	  	assert active(AssignmentAsExpression.main_region.Divide) 
+	  	assert g == 1	  	
+	  	
+	  	cycle
+	  	assert active(AssignmentAsExpression.main_region.Modulo)
+	  	assert i == 1
+
+	  	cycle
+	  	assert active(AssignmentAsExpression.main_region.Shift)
+		assert j == 16
+		assert k == 4
+		
+	  	cycle
+	  	assert active(AssignmentAsExpression.main_region.boolean_And)
+		assert l == 1
+
+	  	cycle
+	  	assert active(AssignmentAsExpression.main_region.boolean_Or)
+		assert p == 15
+		
+	  	cycle
+	  	assert active(AssignmentAsExpression.main_region.boolean_Xor)
+		assert u == 12		
+	  	
+	  	exit
+	  } 
+	 
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/BitExpression.sctunit

@@ -1,6 +1,7 @@
-testgroup BitExpressions for statechart BitExpressions {
+package tests
+testclass BitExpressions for statechart BitExpressions {
 	
-	test BitExpressions {
+	operation BitExpressions(){
 		enter
 		assert active ( BitExpressions.main_region.StateA)
 		assert myBit1 == 5

test-plugins/org.yakindu.sct.test.models/tests/BooleanExpressions.sctunit

@@ -1,5 +1,6 @@
-testgroup BooleanExpressions for statechart BooleanExpressions {
-	test booleanExpressions {
+package tests
+testclass BooleanExpressions for statechart BooleanExpressions {
+	operation booleanExpressions(){
 		enter
 		assert active (BooleanExpressions.main_region.StateA)
 		assert myBool1 == true

test-plugins/org.yakindu.sct.test.models/tests/CKeywords.sctunit

@@ -1,5 +1,6 @@
-testgroup CKeywords for statechart CKeywords { 
-	test CKeywordsTest { 
+package tests
+testclass CKeywords for statechart CKeywords { 
+	operation CKeywordsTest(){ 
 		enter
 		assert active ( CKeywords.auto.char ) 
 		raise auto 

test-plugins/org.yakindu.sct.test.models/tests/CastExpressions.sctunit

@@ -1,16 +1,16 @@
-
-testgroup CastExpressions for statechart CastExpressions{
-	
-	test CastExpressionTest { 
-		enter
-		assert realValue == 5
-		assert intValue == 5
-		cycle
-		assert realValue == 15
-		cycle
-		assert active(CastExpressions.main_region.C)
-		
-		assert realValue == 757
-	} 
-}
+package tests
+testclass CastExpressions for statechart CastExpressions{
+	
+	operation CastExpressionTest(){ 
+		enter
+		assert realValue == 5
+		assert intValue == 5
+		cycle
+		assert realValue == 15
+		cycle
+		assert active(CastExpressions.main_region.C)
+		
+		assert realValue == 757
+	} 
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/Choice.sctunit

@@ -1,6 +1,7 @@
-testgroup Choice for statechart Choice { 
+package tests
+testclass Choice for statechart Choice { 
 
-	test elseChoiceUsingNonDefaultTransition {
+	operation elseChoiceUsingNonDefaultTransition(){
 		enter
 		
 		assert active (Choice.main_region.A)
@@ -11,7 +12,7 @@ testgroup Choice for statechart Choice {
 		assert active (Choice.main_region.C)
 	}
 	
-	test elseChoiceUsingDefaultTransition {
+	operation elseChoiceUsingDefaultTransition(){
 		enter
 		
 		assert active (Choice.main_region.A)
@@ -22,7 +23,7 @@ testgroup Choice for statechart Choice {
 		assert active (Choice.main_region.B)
 	}
 	
-	test defaultChoiceUsingNonDefaultTransition {
+	operation defaultChoiceUsingNonDefaultTransition(){
 		enter
 		
 		assert active (Choice.main_region.A)
@@ -33,7 +34,7 @@ testgroup Choice for statechart Choice {
 		assert active (Choice.main_region.C)
 	}
 	
-	test defaultChoiceUsingDefaultTransition {
+	operation defaultChoiceUsingDefaultTransition(){
 		enter
 		
 		assert active (Choice.main_region.A)
@@ -44,7 +45,7 @@ testgroup Choice for statechart Choice {
 		assert active (Choice.main_region.B)
 	}
 	
-	test uncheckedChoiceUsingNonDefaultTransition {
+	operation uncheckedChoiceUsingNonDefaultTransition(){
 		enter
 		
 		assert active (Choice.main_region.A)
@@ -59,7 +60,7 @@ testgroup Choice for statechart Choice {
 	 * An outgiong transition with an empty trigger 
 	 * will be handled like a default transition. 
 	 */
-	test uncheckedChoiceUsingDefaultTransition {
+	operation uncheckedChoiceUsingDefaultTransition(){
 		enter
 		
 		assert active (Choice.main_region.A)
@@ -76,7 +77,7 @@ testgroup Choice for statechart Choice {
 	 * This test case makes sure that default transition reordering
 	 * does not impact these transitions.
 	 */
-	test alwaysTrueTransitionInChoice {
+	operation alwaysTrueTransitionInChoice(){
 		enter
 		
 		assert active (Choice.main_region.A)

test-plugins/org.yakindu.sct.test.models/tests/ConditionalExpression.sctunit

@@ -1,21 +1,21 @@
-
-testgroup ConditionalExpression for statechart ConditionalExpressions{
-	
-	test ConditionalExpressionTest { 
-		enter
-		assert active (ConditionalExpressions.main_region.A)
-		assert condition == 1
-		
-		raise e
-		cycle
-		
-		assert active (ConditionalExpressions.main_region.B)
-		assert condition == 2
-		
-		
-		
-		 
-		 
-	} 
-}
+package tests
+testclass ConditionalExpression for statechart ConditionalExpressions{
+	
+	operation ConditionalExpressionTest(){ 
+		enter
+		assert active (ConditionalExpressions.main_region.A)
+		assert condition == 1
+		
+		raise e
+		cycle
+		
+		assert active (ConditionalExpressions.main_region.B)
+		assert condition == 2
+		
+		
+		
+		 
+		 
+	} 
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/declarations/ConstOnlyDefaultScope.sctunit

@@ -1,26 +1,26 @@
-
-testgroup ConstOnlyDefaultScope for statechart declarations.ConstOnlyDefaultScope {
-
-	/*
-	 * Test is the statechart is entered correctly.
-	 */	
-	test statechartEntry { 		
-		enter		 
-		assert active(declarations.ConstOnlyDefaultScope.main_region.A)
-	
-	} 
-	
-
-	/*
-	 * Test is the statechart is entered correctly.
-	 */	
-	test stateTransition {
-		
-		enter
-		raise A.e : 1
-		cycle
-		assert active(declarations.ConstOnlyDefaultScope.main_region.B)
-		
-	}
-}
+package tests
+testclass ConstOnlyDefaultScope for statechart declarations.ConstOnlyDefaultScope {
+
+	/*
+	 * Test is the statechart is entered correctly.
+	 */	
+	operation statechartEntry(){ 		
+		enter		 
+		assert active(declarations.ConstOnlyDefaultScope.main_region.A)
+	
+	} 
+	
+
+	/*
+	 * Test is the statechart is entered correctly.
+	 */	
+	operation stateTransition(){
+		
+		enter
+		raise A.e : 1
+		cycle
+		assert active(declarations.ConstOnlyDefaultScope.main_region.B)
+		
+	}
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/declarations/ConstOnlyInternalScope.sctunit

@@ -1,26 +1,26 @@
-
-testgroup ConstOnlyInternalScope for statechart declarations.ConstOnlyInternalScope {
-
-	/*
-	 * Test is the statechart is entered correctly.
-	 */	
-	test statechartEntry { 		
-		enter		 
-		assert active(declarations.ConstOnlyInternalScope.main_region.A)
-	
-	} 
-	
-
-	/*
-	 * Test is the statechart is entered correctly.
-	 */	
-	test stateTransition {
-		
-		enter
-		raise e : 1
-		cycle
-		assert active(declarations.ConstOnlyInternalScope.main_region.B)
-		
-	}
-}
+package tests
+testclass ConstOnlyInternalScope for statechart declarations.ConstOnlyInternalScope {
+
+	/*
+	 * Test is the statechart is entered correctly.
+	 */	
+	operation statechartEntry(){ 		
+		enter		 
+		assert active(declarations.ConstOnlyInternalScope.main_region.A)
+	
+	} 
+	
+
+	/*
+	 * Test is the statechart is entered correctly.
+	 */	
+	operation stateTransition(){
+		
+		enter
+		raise e : 1
+		cycle
+		assert active(declarations.ConstOnlyInternalScope.main_region.B)
+		
+	}
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/declarations/ConstOnlyNamedScope.sctunit

@@ -1,26 +1,26 @@
-
-testgroup ConstOnlyNamedScope for statechart declarations.ConstOnlyNamedScope {
-
-	/*
-	 * Test is the statechart is entered correctly.
-	 */	
-	test statechartEntry { 		
-		enter		 
-		assert active(declarations.ConstOnlyNamedScope.main_region.A)
-	
-	} 
-	
-
-	/*
-	 * Test is the statechart is entered correctly.
-	 */	
-	test stateTransition {
-		
-		enter
-		raise e : 1
-		cycle
-		assert active(declarations.ConstOnlyNamedScope.main_region.B)
-		
-	}
-}
+package tests
+testclass ConstOnlyNamedScope for statechart declarations.ConstOnlyNamedScope {
+
+	/*
+	 * Test is the statechart is entered correctly.
+	 */	
+	operation statechartEntry(){ 		
+		enter		 
+		assert active(declarations.ConstOnlyNamedScope.main_region.A)
+	
+	} 
+	
+
+	/*
+	 * Test is the statechart is entered correctly.
+	 */	
+	operation stateTransition(){
+		
+		enter
+		raise e : 1
+		cycle
+		assert active(declarations.ConstOnlyNamedScope.main_region.B)
+		
+	}
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/Constants.sctunit

@@ -1,30 +1,30 @@
-
-testgroup ConstantsTests for statechart Constants {
-
-	test constantDefinition { 
-		enter
-		assert active(Constants.main_region.A)
-		//After initialization, constant values must be set
-		assert x == 10
-		assert y == 20
-		assert Named.y == "Hello World"
-		//Caluclation with constants 
-		raise e
-		cycle
-		assert result == 20
-		
-		raise e
-		cycle
-		
-		
-		assert active(Constants.main_region.C)
-		assert result == 100
-		
-		raise e2 : x
-		cycle
-	
-		assert result == 1000
-		assert active(Constants.main_region.A)
-	} 
-}
+package tests
+testclass ConstantsTests for statechart Constants {
+
+	operation constantDefinition(){ 
+		enter
+		assert active(Constants.main_region.A)
+		//After initialization, constant values must be set
+		assert x == 10
+		assert y == 20
+		assert Named.y == "Hello World"
+		//Caluclation with constants 
+		raise e
+		cycle
+		assert result == 20
+		
+		raise e
+		cycle
+		
+		
+		assert active(Constants.main_region.C)
+		assert result == 100
+		
+		raise e2 : x
+		cycle
+	
+		assert result == 1000
+		assert active(Constants.main_region.A)
+	} 
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/Declarations.sctunit

@@ -1,6 +1,7 @@
-testgroup Declarations for statechart Declarations {
+package tests
+testclass Declarations for statechart Declarations {
 	
-	test declarationsTest {
+	operation declarationsTest(){
 		enter
 	}
 }

test-plugins/org.yakindu.sct.test.models/tests/DeepEntry.sctunit

@@ -1,28 +1,27 @@
-
-
-testgroup DeepEntry for statechart DeepEntry {
-	
-	test enterToSubstate {
-		
-		assert x == 0
-		assert y == 0
-		assert z == 0
-		enter
-		assert x == 1
-		assert y == 1
-		assert z == 2
-		
-		raise e
-		cycle
-		assert active ( DeepEntry.r2.B.r.BB )
-
-		raise f
-		cycle
-		assert active ( DeepEntry.r2.C )
-		
-		raise f
-		cycle
-		assert active ( DeepEntry.r2.B.r.BB )
-		assert y == 1
-	}
+package tests
+testclass DeepEntry for statechart DeepEntry {
+	
+	operation enterToSubstate(){
+		
+		assert x == 0
+		assert y == 0
+		assert z == 0
+		enter
+		assert x == 1
+		assert y == 1
+		assert z == 2
+		
+		raise e
+		cycle
+		assert active ( DeepEntry.r2.B.r.BB )
+
+		raise f
+		cycle
+		assert active ( DeepEntry.r2.C )
+		
+		raise f
+		cycle
+		assert active ( DeepEntry.r2.B.r.BB )
+		assert y == 1
+	}
 }

test-plugins/org.yakindu.sct.test.models/tests/DeepHistory.sctunit

@@ -1,5 +1,6 @@
-testgroup DeepHistory for statechart DeepHistory {
-	test deepHistoryTest {
+package tests
+testclass DeepHistory for statechart DeepHistory {
+	operation deepHistoryTest(){
 		// Change active states to State9;
 		
 		enter

test-plugins/org.yakindu.sct.test.models/tests/DynamicChoice.sctunit

@@ -1,11 +1,11 @@
-
-testgroup DynamicChoice for statechart DynamicChoice{
-	
-	test DynamicChoiceTest { 
-		enter		
-		assert active(DynamicChoice.main_region.Start)
-		cycle
-		assert active(DynamicChoice.main_region.A)	 
-	} 
-}
+package tests
+testclass DynamicChoice for statechart DynamicChoice{
+	
+	operation DynamicChoiceTest(){ 
+		enter		
+		assert active(DynamicChoice.main_region.Start)
+		cycle
+		assert active(DynamicChoice.main_region.A)	 
+	} 
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/EmptyTransition.sctunit

@@ -1,11 +1,11 @@
-
-testgroup EmptyTransition for statechart EmptyTransition{
-	test EmptyTransitionTest { 
-		enter
-		cycle
-		assert !active (EmptyTransition.main_region.B)
-		assert active  (EmptyTransition.main_region.A) 
-		 
-	} 
-}
+package tests
+testclass EmptyTransition for statechart EmptyTransition{
+	operation EmptyTransitionTest(){ 
+		enter
+		cycle
+		assert !active (EmptyTransition.main_region.B)
+		assert active  (EmptyTransition.main_region.A) 
+		 
+	} 
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/EnterState.sctunit

@@ -1,40 +1,40 @@
-
-testgroup EnterState for statechart EnterState {
-	
-		
-	/* An entry without a specified entry point must enter the region through the default entry.
-	 */
-	test defaultEntry { 
-		enter
-		assert active(EnterState.r.A)
-		
-		raise e
-		cycle
-		assert active(EnterState.r.B.r.E) 
-	} 
-
-	/* An entry with a specified entry point must take the entry node with the specified name.
-	 */
-	test namedEntryThroughNamedTransition { 
-		enter
-		assert active(EnterState.r.A)
-		
-		raise f
-		cycle
-		assert active(EnterState.r.B.r.F) 
-	} 
-
-	/* An entry with a specified entry point that does not match any entry node by name must be taken through the default entry node.
-	 */
-	test namedEntryThroughDefaultTransition { 
-		enter
-		assert active(EnterState.r.A)
-		
-		raise g
-		cycle
-		assert active(EnterState.r.B.r.E) 
-	} 
-	
-	 
-}
+package tests
+testclass EnterState for statechart EnterState {
+	
+		
+	/* An entry without a specified entry point must enter the region through the default entry.
+	 */
+	operation defaultEntry(){ 
+		enter
+		assert active(EnterState.r.A)
+		
+		raise e
+		cycle
+		assert active(EnterState.r.B.r.E) 
+	} 
+
+	/* An entry with a specified entry point must take the entry node with the specified name.
+	 */
+	operation namedEntryThroughNamedTransition(){ 
+		enter
+		assert active(EnterState.r.A)
+		
+		raise f
+		cycle
+		assert active(EnterState.r.B.r.F) 
+	} 
+
+	/* An entry with a specified entry point that does not match any entry node by name must be taken through the default entry node.
+	 */
+	operation namedEntryThroughDefaultTransition(){ 
+		enter
+		assert active(EnterState.r.A)
+		
+		raise g
+		cycle
+		assert active(EnterState.r.B.r.E) 
+	} 
+	
+	 
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/EntryChoice.sctunit

@@ -1,9 +1,10 @@
-testgroup EntryChoice for statechart EntryChoice {
-	test EntryChoiceTest {
-		enter
-		cycle
-		cycle
-		assert active ( EntryChoice.main_region.A )
-	}
-}
+package tests
+testclass EntryChoice for statechart EntryChoice {
+	operation EntryChoiceTest(){
+		enter
+		cycle
+		cycle
+		assert active ( EntryChoice.main_region.A )
+	}
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/EntryExitSelfTransition.sctunit

@@ -1,41 +1,41 @@
-
-testgroup EntryExitSelfTransition for statechart EntryExitSelfTransition{
-
-	test SelfTransitionToChildState { 
-		enter
-		
-		cycle
-		assert entries == 1 
-		assert active(EntryExitSelfTransition.main_region.A._region0.B)
-		
-		entries = 0
-		raise e
-		cycle
-		assert entries == 1
-		assert exits == 1
-		assert active(EntryExitSelfTransition.main_region.A._region0.C)
-	} 
-
-
-	test SelfTransitionFromChildState { 
-		enter
-		
-		cycle
-		assert entries == 1 
-		
-		entries = 0
-		raise e1
-		cycle
-		assert entries == 0
-		assert exits == 0
-		assert active(EntryExitSelfTransition.main_region.A._region0.C)
-	
-		raise e1
-		cycle
-		assert active(EntryExitSelfTransition.main_region.A._region0.B)
-		assert entries == 1
-		assert exits == 1 
-	} 
-
-}
+package tests
+testclass EntryExitSelfTransition for statechart EntryExitSelfTransition{
+
+	operation SelfTransitionToChildState(){ 
+		enter
+		
+		cycle
+		assert entries == 1 
+		assert active(EntryExitSelfTransition.main_region.A._region0.B)
+		
+		entries = 0
+		raise e
+		cycle
+		assert entries == 1
+		assert exits == 1
+		assert active(EntryExitSelfTransition.main_region.A._region0.C)
+	} 
+
+
+	operation SelfTransitionFromChildState(){ 
+		enter
+		
+		cycle
+		assert entries == 1 
+		
+		entries = 0
+		raise e1
+		cycle
+		assert entries == 0
+		assert exits == 0
+		assert active(EntryExitSelfTransition.main_region.A._region0.C)
+	
+		raise e1
+		cycle
+		assert active(EntryExitSelfTransition.main_region.A._region0.B)
+		assert entries == 1
+		assert exits == 1 
+	} 
+
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/entries/EntryReactionAction.sctunit

@@ -1,72 +1,72 @@
-
-testgroup EntryReactionAction for statechart entries.EntryReactionAction {
-
-	/*
-	 * Actions on an entry transition should be executed during entering the state machine.
-	 */	
-	test entryTransitionActionOnStatechartEnter { 
-		
-		enter		 
-		assert enteredR1
-		assert enteredR2
-		assert enteredBdefault
-		assert ! enteredBother
-		
-	} 
-	
-	/*
-	 * Actions on an entry transition should be executed if it is used during a run to completion step.
-	 */
-	test entryOnRTS {
-		enter
-		
-		raise b 
-		cycle 
-		raise d 
-		cycle
-		
-		enteredR1 = false
-		enteredR2 = false
-		enteredBdefault = false
-		enteredBother = false
-		raise b
-		cycle
-		
-		assert ! enteredR1
-		assert ! enteredR2
-		assert ! enteredBdefault
-		assert enteredBother		
-		
-	}
-	
-	
-	/*
-	 * Actions on an entry transition should not be executed if be executed when entering 
-	 * a region using a history.
-	 */
-	test noEntryTransitionActionOnHistory {
-		
-		enter
-		
-		raise b
-		cycle
-		raise d
-		cycle
-		
-		enteredR1 = false
-		enteredR2 = false
-		enteredBdefault = false
-		enteredBother = false
-		raise d
-		cycle
-		
-		assert ! enteredR1
-		assert ! enteredR2
-		assert ! enteredBdefault
-		assert ! enteredBother		
-	}
-
-
-	
-}
+package tests
+testclass EntryReactionAction for statechart entries.EntryReactionAction {
+
+	/*
+	 * Actions on an entry transition should be executed during entering the state machine.
+	 */	
+	operation entryTransitionActionOnStatechartEnter(){ 
+		
+		enter		 
+		assert enteredR1
+		assert enteredR2
+		assert enteredBdefault
+		assert ! enteredBother
+		
+	} 
+	
+	/*
+	 * Actions on an entry transition should be executed if it is used during a run to completion step.
+	 */
+	operation entryOnRTS(){
+		enter
+		
+		raise b 
+		cycle 
+		raise d 
+		cycle
+		
+		enteredR1 = false
+		enteredR2 = false
+		enteredBdefault = false
+		enteredBother = false
+		raise b
+		cycle
+		
+		assert ! enteredR1
+		assert ! enteredR2
+		assert ! enteredBdefault
+		assert enteredBother		
+		
+	}
+	
+	
+	/*
+	 * Actions on an entry transition should not be executed if be executed when entering 
+	 * a region using a history.
+	 */
+	operation noEntryTransitionActionOnHistory(){
+		
+		enter
+		
+		raise b
+		cycle
+		raise d
+		cycle
+		
+		enteredR1 = false
+		enteredR2 = false
+		enteredBdefault = false
+		enteredBother = false
+		raise d
+		cycle
+		
+		assert ! enteredR1
+		assert ! enteredR2
+		assert ! enteredBdefault
+		assert ! enteredBother		
+	}
+
+
+	
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/ExitOnSelfTransition.sctunit

@@ -1,22 +1,22 @@
-
-testgroup ExitOnSelfTransition for statechart ExitOnSelfTransition {
-	test ExitOnSelfTransitionTest { 
-		
-		enter
-		
-		assert active(ExitOnSelfTransition.main_region.A) 
-		assert entryCount == 1 
-		assert exitCount == 0
-		
-		raise e
-		cycle
-		assert entryCount == 2
-		assert exitCount == 1
-		
-		raise f
-		cycle
-		assert entryCount == 2
-		assert exitCount == 2 
-	} 
-}
+package tests
+testclass ExitOnSelfTransition for statechart ExitOnSelfTransition {
+	operation ExitOnSelfTransitionTest(){ 
+		
+		enter
+		
+		assert active(ExitOnSelfTransition.main_region.A) 
+		assert entryCount == 1 
+		assert exitCount == 0
+		
+		raise e
+		cycle
+		assert entryCount == 2
+		assert exitCount == 1
+		
+		raise f
+		cycle
+		assert entryCount == 2
+		assert exitCount == 2 
+	} 
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/ExitState.sctunit

@@ -1,45 +1,45 @@
-
-testgroup ExitState for statechart ExitState {
-	
-	/* An exit through an unnamed exit point must be taken by the transition without exit point spec (it must also be unguarded). */
-	test defaultExit { 
-		enter
-		assert active(ExitState.r.A)
-		
-		raise e
-		cycle
-		assert active(ExitState.r.E) 
-	} 
-
-	/* An exit through an named exit point must be taken by the transition with the matching exit point spec if it exists. */
-	test namedExitThroughNamedTransition { 
-		enter
-		assert active(ExitState.r.A)
-		
-		raise f
-		cycle
-		assert active(ExitState.r.F) 
-	} 
-
-	/* An exit through an named exit point must be taken by the default transition if no transition for this exit point exists.  */
-	test namedExitThroughDefaultTransition { 
-		enter
-		assert active(ExitState.r.A)
-		
-		raise g
-		cycle
-		assert active(ExitState.r.E) 
-	} 
-
-
-	/* If no event is raised then the statechart must remain in state A.  */
-	test remainInA { 
-		enter
-		assert active(ExitState.r.A)
-		
-		cycle
-		assert active(ExitState.r.A) 
-	} 
-
-}
+package tests
+testclass ExitState for statechart ExitState {
+	
+	/* An exit through an unnamed exit point must be taken by the transition without exit point spec (it must also be unguarded). */
+	operation defaultExit(){ 
+		enter
+		assert active(ExitState.r.A)
+		
+		raise e
+		cycle
+		assert active(ExitState.r.E) 
+	} 
+
+	/* An exit through an named exit point must be taken by the transition with the matching exit point spec if it exists. */
+	operation namedExitThroughNamedTransition(){ 
+		enter
+		assert active(ExitState.r.A)
+		
+		raise f
+		cycle
+		assert active(ExitState.r.F) 
+	} 
+
+	/* An exit through an named exit point must be taken by the default transition if no transition for this exit point exists.  */
+	operation namedExitThroughDefaultTransition(){ 
+		enter
+		assert active(ExitState.r.A)
+		
+		raise g
+		cycle
+		assert active(ExitState.r.E) 
+	} 
+
+
+	/* If no event is raised then the statechart must remain in state A.  */
+	operation remainInA(){ 
+		enter
+		assert active(ExitState.r.A)
+		
+		cycle
+		assert active(ExitState.r.A) 
+	} 
+
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/FeatureCalls.sctunit

@@ -1,5 +1,6 @@
-testgroup FeatureCalls for statechart FeatureCalls {
-	test FeatureCalls {
+package tests
+testclass FeatureCalls for statechart FeatureCalls {
+	operation FeatureCalls(){
 		enter
 		assert active ( FeatureCalls.main_region.A)
 		//assert MyInterface.myInt == 0

test-plugins/org.yakindu.sct.test.models/tests/FinalState.sctunit

@@ -1,10 +1,10 @@
-
-testgroup FinalState for statechart FinalState{
-	test StatechartNameTest { 
-		enter
-		cycle
-		assert is_final
-		 
-	} 
-}
+package tests
+testclass FinalState for statechart FinalState{
+	operation StatechartNameTest(){ 
+		enter
+		cycle
+		assert is_final
+		 
+	} 
+}
 	

test-plugins/org.yakindu.sct.test.models/tests/Guard.sctunit

@@ -1,5 +1,6 @@
-testgroup Guard for statechart Guard {
-	test guardTest {
+package tests
+testclass Guard for statechart Guard {
+	operation guardTest(){
 		enter
 		assert active (Guard.main_region.A)
 		raise Event1