update Tests, added generated AllTests.

test-plugins/org.yakindu.sct.generator.c.test/model/test.sgen

@@ -1,14 +1,13 @@
 GeneratorModel for sctunit::c {
 
-//	test AllTests{
-//		
-//		feature Outlet{ 
-//			targetProject = "org.yakindu.sct.generator.c.test" 
-//			targetFolder = "test-gen"			
-//		}			
-//	}
-	
-	
+	test AllTests{
+		
+		feature Outlet{ 
+			targetProject = "org.yakindu.sct.generator.c.test" 
+			targetFolder = "test-gen"			
+		}			
+	}
+		
 	test AlwaysOncycle{
 		
 		feature Outlet{ 

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

@@ -1,28 +1,31 @@
-/**
- * Copyright (c) 2013 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.c.test;
-
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-import org.junit.runners.Suite.SuiteClasses;
-
-@RunWith(Suite.class)
-@SuiteClasses({ AlwaysOncycle.class, AssignmentAsExpression.class, BitExpressions.class, BooleanExpressions.class,
-		CKeywords.class, Declarations.class, Choice.class, DeepHistory.class, EnterState.class, ExitState.class,
-		ExitOnSelfTransition.class, Guard.class, GuardedEntry.class, GuardedExit.class,
-		HistoryWithoutInitialStep.class, IntegerExpressions.class, InEventLifeCycle.class,
-		InternalEventLifeCycle.class, OutEventLifeCycle.class, Parenthesis.class, PriorityValues.class,
-		RaiseEvent.class, SameNameDifferentRegion.class, ShallowHistory.class, SimpleHierachy.class,
-		StateIsActive.class, StatechartLocalReactions.class, StringExpressions.class, SyncFork.class, SyncJoin.class,
-		SimpleEvent.class, STextKeywordsInStatesAndRegions.class, TransitionWithoutCondition.class, ValuedEvents.class,
-		NamedInterfaceAccess.class})
-public class AllTests {
-}
+/**
+ * Copyright (c) 2013 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.c.test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({AlwaysOncycle.class, AssignmentAsExpression.class,
+		BitExpressions.class, BooleanExpressions.class, Choice.class,
+		CKeywords.class, Declarations.class, DeepHistory.class,
+		EnterState.class, ExitOnSelfTransition.class, ExitState.class,
+		Guard.class, GuardedEntry.class, GuardedExit.class,
+		HistoryWithoutInitialStep.class, InEventLifeCycle.class,
+		IntegerExpressions.class, InternalEventLifeCycle.class,
+		NamedInterfaceAccess.class, OutEventLifeCycle.class, Parenthesis.class,
+		PriorityValues.class, RaiseEvent.class, SameNameDifferentRegion.class,
+		ShallowHistory.class, SimpleHierachy.class, StateIsActive.class,
+		StatechartLocalReactions.class, StringExpressions.class,
+		SyncFork.class, SyncJoin.class, SimpleEvent.class,
+		STextKeywordsInStatesAndRegions.class})
+public class AllTests {
+}

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

@@ -1,39 +1,39 @@
-/**
- * Copyright (c) 2013 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.c.test;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.generator.c.gtest.GTest;
-import org.yakindu.sct.generator.c.gtest.GTestRunner;
-import org.yakindu.sct.generator.c.gtest.GTestHelper;
-
-@GTest(sourceFile = "gtests/AlwaysOncycle/AlwaysOncycle.cc", program = "gtests/AlwaysOncycle/AlwaysOncycle", model = "testmodels/SCTUnit/AlwaysOncycle.sct")
-@RunWith(GTestRunner.class)
-public class AlwaysOncycle {
-
-	protected final GTestHelper helper = new GTestHelper(this) {
-
-		@Override
-		protected void getSourceFiles(Collection<String> files) {
-			super.getSourceFiles(files);
-			files.add(getFileName(getTestProgram()) + ".c");
-		}
-	};
-
-	@Before
-	public void setUp() {
-		helper.generate();
-		helper.compile();
-	}
-}
+/**
+ * Copyright (c) 2013 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.c.test;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.generator.c.gtest.GTest;
+import org.yakindu.sct.generator.c.gtest.GTestRunner;
+import org.yakindu.sct.generator.c.gtest.GTestHelper;
+
+@GTest(sourceFile = "gtests/AlwaysOncycle/AlwaysOncycle.cc", program = "gtests/AlwaysOncycle/AlwaysOncycle", model = "testmodels/SCTUnit/AlwaysOncycle.sct")
+@RunWith(GTestRunner.class)
+public class AlwaysOncycle {
+
+	protected final GTestHelper helper = new GTestHelper(this) {
+
+		@Override
+		protected void getSourceFiles(Collection<String> files) {
+			super.getSourceFiles(files);
+			files.add(getFileName(getTestProgram()) + ".c");
+		}
+	};
+
+	@Before
+	public void setUp() {
+		helper.generate();
+		helper.compile();
+	}
+}

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

@@ -1,39 +1,39 @@
-/**
- * Copyright (c) 2013 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.c.test;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.generator.c.gtest.GTest;
-import org.yakindu.sct.generator.c.gtest.GTestRunner;
-import org.yakindu.sct.generator.c.gtest.GTestHelper;
-
-@GTest(sourceFile = "gtests/AssignmentAsExpression/AssignmentAsExpression.cc", program = "gtests/AssignmentAsExpression/AssignmentAsExpression", model = "testmodels/SCTUnit/AssignmentAsExpression.sct")
-@RunWith(GTestRunner.class)
-public class AssignmentAsExpression {
-
-	protected final GTestHelper helper = new GTestHelper(this) {
-
-		@Override
-		protected void getSourceFiles(Collection<String> files) {
-			super.getSourceFiles(files);
-			files.add(getFileName(getTestProgram()) + ".c");
-		}
-	};
-
-	@Before
-	public void setUp() {
-		helper.generate();
-		helper.compile();
-	}
-}
+/**
+ * Copyright (c) 2013 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.c.test;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.generator.c.gtest.GTest;
+import org.yakindu.sct.generator.c.gtest.GTestRunner;
+import org.yakindu.sct.generator.c.gtest.GTestHelper;
+
+@GTest(sourceFile = "gtests/AssignmentAsExpression/AssignmentAsExpression.cc", program = "gtests/AssignmentAsExpression/AssignmentAsExpression", model = "testmodels/SCTUnit/AssignmentAsExpression.sct")
+@RunWith(GTestRunner.class)
+public class AssignmentAsExpression {
+
+	protected final GTestHelper helper = new GTestHelper(this) {
+
+		@Override
+		protected void getSourceFiles(Collection<String> files) {
+			super.getSourceFiles(files);
+			files.add(getFileName(getTestProgram()) + ".c");
+		}
+	};
+
+	@Before
+	public void setUp() {
+		helper.generate();
+		helper.compile();
+	}
+}

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

@@ -1,39 +1,39 @@
-/**
- * Copyright (c) 2013 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.c.test;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.generator.c.gtest.GTest;
-import org.yakindu.sct.generator.c.gtest.GTestRunner;
-import org.yakindu.sct.generator.c.gtest.GTestHelper;
-
-@GTest(sourceFile = "gtests/BitExpressions/BitExpressions.cc", program = "gtests/BitExpressions/BitExpressions", model = "testmodels/SCTUnit/BitExpressions.sct")
-@RunWith(GTestRunner.class)
-public class BitExpressions {
-
-	protected final GTestHelper helper = new GTestHelper(this) {
-
-		@Override
-		protected void getSourceFiles(Collection<String> files) {
-			super.getSourceFiles(files);
-			files.add(getFileName(getTestProgram()) + ".c");
-		}
-	};
-
-	@Before
-	public void setUp() {
-		helper.generate();
-		helper.compile();
-	}
-}
+/**
+ * Copyright (c) 2013 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.c.test;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.generator.c.gtest.GTest;
+import org.yakindu.sct.generator.c.gtest.GTestRunner;
+import org.yakindu.sct.generator.c.gtest.GTestHelper;
+
+@GTest(sourceFile = "gtests/BitExpressions/BitExpressions.cc", program = "gtests/BitExpressions/BitExpressions", model = "testmodels/SCTUnit/BitExpressions.sct")
+@RunWith(GTestRunner.class)
+public class BitExpressions {
+
+	protected final GTestHelper helper = new GTestHelper(this) {
+
+		@Override
+		protected void getSourceFiles(Collection<String> files) {
+			super.getSourceFiles(files);
+			files.add(getFileName(getTestProgram()) + ".c");
+		}
+	};
+
+	@Before
+	public void setUp() {
+		helper.generate();
+		helper.compile();
+	}
+}

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

@@ -1,39 +1,39 @@
-/**
- * Copyright (c) 2013 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.c.test;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.generator.c.gtest.GTest;
-import org.yakindu.sct.generator.c.gtest.GTestRunner;
-import org.yakindu.sct.generator.c.gtest.GTestHelper;
-
-@GTest(sourceFile = "gtests/BooleanExpressions/BooleanExpressions.cc", program = "gtests/BooleanExpressions/BooleanExpressions", model = "testmodels/SCTUnit/BooleanExpressions.sct")
-@RunWith(GTestRunner.class)
-public class BooleanExpressions {
-
-	protected final GTestHelper helper = new GTestHelper(this) {
-
-		@Override
-		protected void getSourceFiles(Collection<String> files) {
-			super.getSourceFiles(files);
-			files.add(getFileName(getTestProgram()) + ".c");
-		}
-	};
-
-	@Before
-	public void setUp() {
-		helper.generate();
-		helper.compile();
-	}
-}
+/**
+ * Copyright (c) 2013 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.c.test;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.generator.c.gtest.GTest;
+import org.yakindu.sct.generator.c.gtest.GTestRunner;
+import org.yakindu.sct.generator.c.gtest.GTestHelper;
+
+@GTest(sourceFile = "gtests/BooleanExpressions/BooleanExpressions.cc", program = "gtests/BooleanExpressions/BooleanExpressions", model = "testmodels/SCTUnit/BooleanExpressions.sct")
+@RunWith(GTestRunner.class)
+public class BooleanExpressions {
+
+	protected final GTestHelper helper = new GTestHelper(this) {
+
+		@Override
+		protected void getSourceFiles(Collection<String> files) {
+			super.getSourceFiles(files);
+			files.add(getFileName(getTestProgram()) + ".c");
+		}
+	};
+
+	@Before
+	public void setUp() {
+		helper.generate();
+		helper.compile();
+	}
+}

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

@@ -1,39 +1,39 @@
-/**
- * Copyright (c) 2013 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.c.test;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.generator.c.gtest.GTest;
-import org.yakindu.sct.generator.c.gtest.GTestRunner;
-import org.yakindu.sct.generator.c.gtest.GTestHelper;
-
-@GTest(sourceFile = "gtests/Choice/Choice.cc", program = "gtests/Choice/Choice", model = "testmodels/SCTUnit/Choice.sct")
-@RunWith(GTestRunner.class)
-public class Choice {
-
-	protected final GTestHelper helper = new GTestHelper(this) {
-
-		@Override
-		protected void getSourceFiles(Collection<String> files) {
-			super.getSourceFiles(files);
-			files.add(getFileName(getTestProgram()) + ".c");
-		}
-	};
-
-	@Before
-	public void setUp() {
-		helper.generate();
-		helper.compile();
-	}
-}
+/**
+ * Copyright (c) 2013 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.c.test;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.generator.c.gtest.GTest;
+import org.yakindu.sct.generator.c.gtest.GTestRunner;
+import org.yakindu.sct.generator.c.gtest.GTestHelper;
+
+@GTest(sourceFile = "gtests/Choice/Choice.cc", program = "gtests/Choice/Choice", model = "testmodels/SCTUnit/Choice.sct")
+@RunWith(GTestRunner.class)
+public class Choice {
+
+	protected final GTestHelper helper = new GTestHelper(this) {
+
+		@Override
+		protected void getSourceFiles(Collection<String> files) {
+			super.getSourceFiles(files);
+			files.add(getFileName(getTestProgram()) + ".c");
+		}
+	};
+
+	@Before
+	public void setUp() {
+		helper.generate();
+		helper.compile();
+	}
+}

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2013 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,
+		ChoiceTest.class, CKeywordsTest.class, DeclarationsTest.class,
+		DeepHistoryTest.class, EnterStateTest.class,
+		ExitOnSelfTransitionTest.class, ExitStateTest.class, GuardTest.class,
+		GuardedEntryTest.class, GuardedExitTest.class,
+		HistoryWithoutInitialStepTest.class, InEventLifeCycleTest.class,
+		IntegerExpressionsTest.class, InternalEventLifeCycleTest.class,
+		NamedInterfaceAccessTest.class, OutEventLifeCycleTest.class,
+		ParenthesisTest.class, PriorityValuesTest.class, RaiseEventTest.class,
+		SameNameDifferentRegionTest.class, ShallowHistoryTest.class,
+		SimpleHierachyTest.class, StateIsActiveTest.class,
+		StatechartLocalReactionsTest.class, StringExpressionsTest.class,
+		SyncForkTest.class, SyncJoinTest.class, SimpleEventTest.class,
+		STextKeywordsInStatesAndRegionsTest.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,56 @@
-/**
- * Copyright (c) 2013 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() < 5) {
-			statemachine.runCycle();
-			assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		}
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		while (statemachine.getValue() < 5) {
-			statemachine.runCycle();
-			assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		}
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-	}
-}
+/**
+ * Copyright (c) 2013 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() < 5) {
+			statemachine.runCycle();
+			assertTrue(statemachine.isStateActive(State.main_region_StateA));
+		}
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_StateB));
+		while (statemachine.getValue() < 5) {
+			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,72 @@
-/**
- * Copyright (c) 2013 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() == 5);
-		assertTrue(statemachine.getA() == 9);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Subtract));
-		assertTrue(statemachine.getD() == 6);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Multiply));
-		assertTrue(statemachine.getE() == 15);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Divide));
-		assertTrue(statemachine.getG() == 1);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Modulo));
-		assertTrue(statemachine.getI() == 1);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_Shift));
-		assertTrue(statemachine.getJ() == 16);
-		assertTrue(statemachine.getK() == 4);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_boolean_And));
-		assertTrue(statemachine.getL() == 1);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_boolean_Or));
-		assertTrue(statemachine.getP() == 15);
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_boolean_Xor));
-		assertTrue(statemachine.getU() == 12);
-		statemachine.exit();
-	}
-}
+/**
+ * Copyright (c) 2013 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() == 5);
+		assertTrue(statemachine.getA() == 9);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Subtract));
+		assertTrue(statemachine.getD() == 6);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Multiply));
+		assertTrue(statemachine.getE() == 15);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Divide));
+		assertTrue(statemachine.getG() == 1);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Modulo));
+		assertTrue(statemachine.getI() == 1);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Shift));
+		assertTrue(statemachine.getJ() == 16);
+		assertTrue(statemachine.getK() == 4);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_boolean_And));
+		assertTrue(statemachine.getL() == 1);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_boolean_Or));
+		assertTrue(statemachine.getP() == 15);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_boolean_Xor));
+		assertTrue(statemachine.getU() == 12);
+		statemachine.exit();
+	}
+}

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

@@ -1,55 +1,55 @@
-/**
- * Copyright (c) 2013 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() == 5);
-		assertTrue(statemachine.getMyBit2() == 7);
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		assertTrue(statemachine.getLeftBitshift() == 10);
-		assertTrue(statemachine.getRightBitshift() == 2);
-		assertTrue(statemachine.getComplementBitshift() == -6);
-		assertTrue(statemachine.getBitwiseAnd() == 5);
-		assertTrue(statemachine.getBitwiseOr() == 7);
-		assertTrue(statemachine.getBitwiseXor() == 2);
-	}
-}
+/**
+ * Copyright (c) 2013 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() == 5);
+		assertTrue(statemachine.getMyBit2() == 7);
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_StateB));
+		assertTrue(statemachine.getLeftBitshift() == 10);
+		assertTrue(statemachine.getRightBitshift() == 2);
+		assertTrue(statemachine.getComplementBitshift() == -6);
+		assertTrue(statemachine.getBitwiseAnd() == 5);
+		assertTrue(statemachine.getBitwiseOr() == 7);
+		assertTrue(statemachine.getBitwiseXor() == 2);
+	}
+}

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

@@ -1,54 +1,54 @@
-/**
- * Copyright (c) 2013 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) 2013 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);
+	}
+}

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

@@ -1,50 +1,50 @@
-/**
- * Copyright (c) 2013 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_const));
-		assertTrue(statemachine.isStateActive(State.auto_const_switch_case));
-		assertTrue(statemachine
-				.isStateActive(State.auto_const_switch_case_enum_asm));
-	}
-}
+/**
+ * Copyright (c) 2013 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_const));
+		assertTrue(statemachine.isStateActive(State.auto_const_switch_case));
+		assertTrue(statemachine
+				.isStateActive(State.auto_const_switch_case_enum_asm));
+	}
+}

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

@@ -1,102 +1,102 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,43 +1,43 @@
-/**
- * Copyright (c) 2013 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) 2013 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();
+	}
+}

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

@@ -1,64 +1,64 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,63 +1,63 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,54 +1,54 @@
-/**
- * Copyright (c) 2013 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() == 1);
-		assertTrue(statemachine.getExitCount() == 0);
-		statemachine.raiseE();
-		statemachine.runCycle();
-		assertTrue(statemachine.getEntryCount() == 2);
-		assertTrue(statemachine.getExitCount() == 1);
-		statemachine.raiseF();
-		statemachine.runCycle();
-		assertTrue(statemachine.getEntryCount() == 2);
-		assertTrue(statemachine.getExitCount() == 2);
-	}
-}
+/**
+ * Copyright (c) 2013 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() == 1);
+		assertTrue(statemachine.getExitCount() == 0);
+		statemachine.raiseE();
+		statemachine.runCycle();
+		assertTrue(statemachine.getEntryCount() == 2);
+		assertTrue(statemachine.getExitCount() == 1);
+		statemachine.raiseF();
+		statemachine.runCycle();
+		assertTrue(statemachine.getEntryCount() == 2);
+		assertTrue(statemachine.getExitCount() == 2);
+	}
+}

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

@@ -1,70 +1,70 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,46 +1,46 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,59 +1,59 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,81 +1,81 @@
-/**
- * Copyright (c) 2013 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) 2013 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());
+	}
+}

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

@@ -1,59 +1,59 @@
-/**
- * Copyright (c) 2013 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) 2013 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());
+	}
+}

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

@@ -1,80 +1,80 @@
-/**
- * Copyright (c) 2013 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.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
-		statemachine.raiseE2();
-		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.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseE2();
-		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.raiseE1();
-		statemachine.runCycle();
-		statemachine.raiseE2();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_A));
-		statemachine.raiseE2();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
-	}
-}
+/**
+ * Copyright (c) 2013 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.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
+		statemachine.raiseE2();
+		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.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_C));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		statemachine.raiseE2();
+		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.raiseE1();
+		statemachine.runCycle();
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_B_r1_D));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_A));
+		statemachine.raiseE2();
+		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,47 @@
-/**
- * Copyright (c) 2013 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() == 0);
-		statemachine.runCycle();
-		assertTrue(statemachine.getI() == 1);
-	}
-}
+/**
+ * Copyright (c) 2013 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() == 0);
+		statemachine.runCycle();
+		assertTrue(statemachine.getI() == 1);
+	}
+}

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

@@ -1,65 +1,65 @@
-/**
- * Copyright (c) 2013 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() == 10);
-		assertTrue(statemachine.getMyInt2() == 5);
-		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() == 15);
-		assertTrue(statemachine.getMinus() == 5);
-		assertTrue(statemachine.getMultiply() == 50);
-		assertTrue(statemachine.getDivision() == 2);
-		assertTrue(statemachine.getModulo() == 0);
-		assertTrue(statemachine.getNegat() == -10);
-		assertTrue(statemachine.getMultiAssign() == 20);
-		assertTrue(statemachine.getDivAssign() == 2);
-		assertTrue(statemachine.getPlusAssign() == 12);
-		assertTrue(statemachine.getMinusAssign() == -8);
-		assertTrue(statemachine.getModuloAssign() == 0);
-	}
-}
+/**
+ * Copyright (c) 2013 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() == 10);
+		assertTrue(statemachine.getMyInt2() == 5);
+		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() == 15);
+		assertTrue(statemachine.getMinus() == 5);
+		assertTrue(statemachine.getMultiply() == 50);
+		assertTrue(statemachine.getDivision() == 2);
+		assertTrue(statemachine.getModulo() == 0);
+		assertTrue(statemachine.getNegat() == -10);
+		assertTrue(statemachine.getMultiAssign() == 20);
+		assertTrue(statemachine.getDivAssign() == 2);
+		assertTrue(statemachine.getPlusAssign() == 12);
+		assertTrue(statemachine.getMinusAssign() == -8);
+		assertTrue(statemachine.getModuloAssign() == 0);
+	}
+}

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

@@ -1,59 +1,59 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,51 +1,51 @@
-/**
- * Copyright (c) 2013 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(3);
-		statemachine.runCycle();
-		statemachine.getSCIUser().raiseNumberPressed(7);
-		statemachine.runCycle();
-		statemachine.getSCIUser().raiseNumberPressed(5);
-		statemachine.runCycle();
-		assertTrue(statemachine.getSCISafe().isRaisedOpen());
-	}
-}
+/**
+ * Copyright (c) 2013 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(3);
+		statemachine.runCycle();
+		statemachine.getSCIUser().raiseNumberPressed(7);
+		statemachine.runCycle();
+		statemachine.getSCIUser().raiseNumberPressed(5);
+		statemachine.runCycle();
+		assertTrue(statemachine.getSCISafe().isRaisedOpen());
+	}
+}

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

@@ -1,69 +1,69 @@
-/**
- * Copyright (c) 2013 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) 2013 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());
+	}
+}

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

@@ -1,45 +1,45 @@
-/**
- * Copyright (c) 2013 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() == 8);
-	}
-}
+/**
+ * Copyright (c) 2013 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() == 8);
+	}
+}

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

@@ -1,95 +1,95 @@
-/**
- * Copyright (c) 2013 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() < 100000) {
-			if (statemachine.isStateActive(State.mr_A)) {
-				statemachine.raiseE1();;
-			} else {
-				if (statemachine.getC() % 2 == 0) {
-					statemachine.raiseE2();;
-				} else {
-					statemachine.raiseE3();;
-				};
-			}
-			statemachine.runCycle();
-		}
-		assertTrue(statemachine.getA() > 2);
-	}
-	@Test
-	public void testtest_1_000_000() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.mr_A));
-		while (statemachine.getC() < 1000000) {
-			if (statemachine.isStateActive(State.mr_A)) {
-				statemachine.raiseE1();;
-			} else {
-				if (statemachine.getC() % 2 == 0) {
-					statemachine.raiseE2();;
-				} else {
-					statemachine.raiseE3();;
-				};
-			}
-			statemachine.runCycle();
-		}
-		assertTrue(statemachine.getA() > 2);
-	}
-	@Test
-	public void testtest_10_000_000() {
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.mr_A));
-		while (statemachine.getC() < 10000000) {
-			if (statemachine.isStateActive(State.mr_A)) {
-				statemachine.raiseE1();;
-			} else {
-				if (statemachine.getC() % 2 == 0) {
-					statemachine.raiseE2();;
-				} else {
-					statemachine.raiseE3();;
-				};
-			}
-			statemachine.runCycle();
-		}
-		assertTrue(statemachine.getA() > 2);
-	}
-}
+/**
+ * Copyright (c) 2013 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() < 100000) {
+			if (statemachine.isStateActive(State.mr_A)) {
+				statemachine.raiseE1();;
+			} else {
+				if (statemachine.getC() % 2 == 0) {
+					statemachine.raiseE2();;
+				} else {
+					statemachine.raiseE3();;
+				};
+			}
+			statemachine.runCycle();
+		}
+		assertTrue(statemachine.getA() > 2);
+	}
+	@Test
+	public void testtest_1_000_000() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.mr_A));
+		while (statemachine.getC() < 1000000) {
+			if (statemachine.isStateActive(State.mr_A)) {
+				statemachine.raiseE1();;
+			} else {
+				if (statemachine.getC() % 2 == 0) {
+					statemachine.raiseE2();;
+				} else {
+					statemachine.raiseE3();;
+				};
+			}
+			statemachine.runCycle();
+		}
+		assertTrue(statemachine.getA() > 2);
+	}
+	@Test
+	public void testtest_10_000_000() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.mr_A));
+		while (statemachine.getC() < 10000000) {
+			if (statemachine.isStateActive(State.mr_A)) {
+				statemachine.raiseE1();;
+			} else {
+				if (statemachine.getC() % 2 == 0) {
+					statemachine.raiseE2();;
+				} else {
+					statemachine.raiseE3();;
+				};
+			}
+			statemachine.runCycle();
+		}
+		assertTrue(statemachine.getA() > 2);
+	}
+}

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

@@ -1,56 +1,56 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,50 +1,50 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,54 +1,54 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,82 +1,82 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,50 +1,50 @@
-/**
- * Copyright (c) 2013 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(5 == 5);
-		statemachine.raiseEvent1();
-		statemachine.runCycle();
-		assertTrue("Expected B to be active",
-				statemachine.isStateActive(State.main_region_B));
-	}
-}
+/**
+ * Copyright (c) 2013 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(5 == 5);
+		statemachine.raiseEvent1();
+		statemachine.runCycle();
+		assertTrue("Expected B to be active",
+				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,51 +1,51 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,50 +1,50 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,54 +1,54 @@
-/**
- * Copyright (c) 2013 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() < 10) {
-			assertTrue(statemachine.isStateActive(State.region2_a));
-			if (statemachine.getMyInt() % 2 == 0) {
-				assertTrue(statemachine.isStateActive(State.main_region_S1));;
-			} else {
-				assertTrue(statemachine.isStateActive(State.main_region_S2));;
-			}
-			statemachine.runCycle();
-		}
-	}
-}
+/**
+ * Copyright (c) 2013 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() < 10) {
+			assertTrue(statemachine.isStateActive(State.region2_a));
+			if (statemachine.getMyInt() % 2 == 0) {
+				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/StringExpressionsTest.java

@@ -1,54 +1,54 @@
-/**
- * Copyright (c) 2013 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.getQuotedString().equals("\"x\""));
-		statemachine.enter();
-		assertTrue(statemachine.isStateActive(State.main_region_StateA));
-		assertTrue(statemachine.getMyString().equals("hello"));
-		assertTrue(statemachine.getMyString2().equals("world"));
-		assertTrue(statemachine.getQuotedString().equals("'y'"));
-		statemachine.raiseE1();
-		statemachine.runCycle();
-		assertTrue(statemachine.isStateActive(State.main_region_StateB));
-		assertTrue(statemachine.getEquals() == false);
-		assertTrue(statemachine.getNotEqual() == true);
-		assertTrue(statemachine.getQuotedString().equals("\"z\""));
-	}
-}
+/**
+ * Copyright (c) 2013 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.getQuotedString().equals("\"x\""));
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_StateA));
+		assertTrue(statemachine.getMyString().equals("hello"));
+		assertTrue(statemachine.getMyString2().equals("world"));
+		assertTrue(statemachine.getQuotedString().equals("'y'"));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_StateB));
+		assertTrue(statemachine.getEquals() == false);
+		assertTrue(statemachine.getNotEqual() == true);
+		assertTrue(statemachine.getQuotedString().equals("\"z\""));
+	}
+}

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

@@ -1,62 +1,62 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,119 +1,119 @@
-/**
- * Copyright (c) 2013 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() == 1);
-	}
-}
+/**
+ * Copyright (c) 2013 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() == 1);
+	}
+}

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

@@ -1,46 +1,46 @@
-/**
- * Copyright (c) 2013 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) 2013 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));
+	}
+}

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

@@ -1,47 +1,47 @@
-/**
- * Copyright (c) 2013 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.isStateActive(State.main_region_A));
-		assertTrue(statemachine.isStateActive(State._region1_C));
-		assertTrue(statemachine.getMyVar() == 42);
-	}
-}
+/**
+ * Copyright (c) 2013 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.isStateActive(State.main_region_A));
+		assertTrue(statemachine.isStateActive(State._region1_C));
+		assertTrue(statemachine.getMyVar() == 42);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/model/test.sgen

@@ -1,14 +1,14 @@
 GeneratorModel for sctunit::interpreter {
 
-//	test AllTests{
-//		
-//		feature Outlet{ 
-//			targetProject = "org.yakindu.sct.model.sexec.interpreter.test" 
-//			targetFolder = "test-gen"			
-//		}			
-//	}
-	
-	test AlwaysOncycle{
+	test AllTests {
+	
+		feature Outlet {
+			targetProject = "org.yakindu.sct.model.sexec.interpreter.test"
+			targetFolder = "test-gen"
+		}
+	}	
+	
+	test AlwaysOncycle{ 
 		
 		feature Outlet{ 
 			targetProject = "org.yakindu.sct.model.sexec.interpreter.test" 

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/AllTestsTest.java

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.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,
+		ChoiceTest.class, CKeywordsTest.class, DeclarationsTest.class,
+		DeepHistoryTest.class, EnterStateTest.class,
+		ExitOnSelfTransitionTest.class, ExitStateTest.class, GuardTest.class,
+		GuardedEntryTest.class, GuardedExitTest.class,
+		HistoryWithoutInitialStepTest.class, InEventLifeCycleTest.class,
+		IntegerExpressionsTest.class, InternalEventLifeCycleTest.class,
+		NamedInterfaceAccessTest.class, OutEventLifeCycleTest.class,
+		ParenthesisTest.class, PriorityValuesTest.class, RaiseEventTest.class,
+		SameNameDifferentRegionTest.class, ShallowHistoryTest.class,
+		SimpleHierachyTest.class, StateIsActiveTest.class,
+		StatechartLocalReactionsTest.class, StringExpressionsTest.class,
+		SyncForkTest.class, SyncJoinTest.class, SimpleEventTest.class,
+		STextKeywordsInStatesAndRegionsTest.class})
+public class AllTestsTest {
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/AlwaysOncycleTest.java

@@ -1,56 +1,56 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for AlwaysOncycle
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class AlwaysOncycleTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("AlwaysOncycle.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void alwaysOncycleTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("StateA"));
-		while (getInteger("value") < 5) {
-			interpreter.runCycle();
-			assertTrue(isActive("StateA"));
-		}
-		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		while (getInteger("value") < 5) {
-			interpreter.runCycle();
-			assertTrue(isActive("StateB"));
-		}
-		interpreter.runCycle();
-		assertTrue(isActive("StateA"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for AlwaysOncycle
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class AlwaysOncycleTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("AlwaysOncycle.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void alwaysOncycleTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		while (getInteger("value") < 5) {
+			interpreter.runCycle();
+			assertTrue(isActive("StateA"));
+		}
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		while (getInteger("value") < 5) {
+			interpreter.runCycle();
+			assertTrue(isActive("StateB"));
+		}
+		interpreter.runCycle();
+		assertTrue(isActive("StateA"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/AssignmentAsExpressionTest.java

@@ -1,72 +1,72 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for AssignmentAsExpression
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class AssignmentAsExpressionTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("AssignmentAsExpression.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void simpleAssignment() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("Add"));
-		assertTrue(getInteger("b") == 5);
-		assertTrue(getInteger("a") == 9);
-		interpreter.runCycle();
-		assertTrue(isActive("Subtract"));
-		assertTrue(getInteger("d") == 6);
-		interpreter.runCycle();
-		assertTrue(isActive("Multiply"));
-		assertTrue(getInteger("e") == 15);
-		interpreter.runCycle();
-		assertTrue(isActive("Divide"));
-		assertTrue(getInteger("g") == 1);
-		interpreter.runCycle();
-		assertTrue(isActive("Modulo"));
-		assertTrue(getInteger("i") == 1);
-		interpreter.runCycle();
-		assertTrue(isActive("Shift"));
-		assertTrue(getInteger("j") == 16);
-		assertTrue(getInteger("k") == 4);
-		interpreter.runCycle();
-		assertTrue(isActive("boolean And"));
-		assertTrue(getInteger("l") == 1);
-		interpreter.runCycle();
-		assertTrue(isActive("boolean Or"));
-		assertTrue(getInteger("p") == 15);
-		interpreter.runCycle();
-		assertTrue(isActive("boolean Xor"));
-		assertTrue(getInteger("u") == 12);
-		interpreter.exit();
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for AssignmentAsExpression
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class AssignmentAsExpressionTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("AssignmentAsExpression.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void simpleAssignment() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("Add"));
+		assertTrue(getInteger("b") == 5);
+		assertTrue(getInteger("a") == 9);
+		interpreter.runCycle();
+		assertTrue(isActive("Subtract"));
+		assertTrue(getInteger("d") == 6);
+		interpreter.runCycle();
+		assertTrue(isActive("Multiply"));
+		assertTrue(getInteger("e") == 15);
+		interpreter.runCycle();
+		assertTrue(isActive("Divide"));
+		assertTrue(getInteger("g") == 1);
+		interpreter.runCycle();
+		assertTrue(isActive("Modulo"));
+		assertTrue(getInteger("i") == 1);
+		interpreter.runCycle();
+		assertTrue(isActive("Shift"));
+		assertTrue(getInteger("j") == 16);
+		assertTrue(getInteger("k") == 4);
+		interpreter.runCycle();
+		assertTrue(isActive("boolean And"));
+		assertTrue(getInteger("l") == 1);
+		interpreter.runCycle();
+		assertTrue(isActive("boolean Or"));
+		assertTrue(getInteger("p") == 15);
+		interpreter.runCycle();
+		assertTrue(isActive("boolean Xor"));
+		assertTrue(getInteger("u") == 12);
+		interpreter.exit();
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/BitExpressionsTest.java

@@ -1,55 +1,55 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for BitExpressions
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class BitExpressionsTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("BitExpressions.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void BitExpressions() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("StateA"));
-		assertTrue(getInteger("myBit1") == 5);
-		assertTrue(getInteger("myBit2") == 7);
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(getInteger("leftBitshift") == 10);
-		assertTrue(getInteger("rightBitshift") == 2);
-		assertTrue(getInteger("complementBitshift") == -6);
-		assertTrue(getInteger("bitwiseAnd") == 5);
-		assertTrue(getInteger("bitwiseOr") == 7);
-		assertTrue(getInteger("bitwiseXor") == 2);
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for BitExpressions
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class BitExpressionsTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("BitExpressions.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void BitExpressions() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		assertTrue(getInteger("myBit1") == 5);
+		assertTrue(getInteger("myBit2") == 7);
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		assertTrue(getInteger("leftBitshift") == 10);
+		assertTrue(getInteger("rightBitshift") == 2);
+		assertTrue(getInteger("complementBitshift") == -6);
+		assertTrue(getInteger("bitwiseAnd") == 5);
+		assertTrue(getInteger("bitwiseOr") == 7);
+		assertTrue(getInteger("bitwiseXor") == 2);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/BooleanExpressionsTest.java

@@ -1,54 +1,54 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for BooleanExpressions
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class BooleanExpressionsTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("BooleanExpressions.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void booleanExpressions() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("StateA"));
-		assertTrue(getBoolean("myBool1") == true);
-		assertTrue(getBoolean("myBool2") == false);
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(getBoolean("and") == false);
-		assertTrue(getBoolean("or") == true);
-		assertTrue(getBoolean("not") == false);
-		assertTrue(getBoolean("equal") == false);
-		assertTrue(getBoolean("notequal") == true);
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for BooleanExpressions
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class BooleanExpressionsTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("BooleanExpressions.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void booleanExpressions() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		assertTrue(getBoolean("myBool1") == true);
+		assertTrue(getBoolean("myBool2") == false);
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		assertTrue(getBoolean("and") == false);
+		assertTrue(getBoolean("or") == true);
+		assertTrue(getBoolean("not") == false);
+		assertTrue(getBoolean("equal") == false);
+		assertTrue(getBoolean("notequal") == true);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/CKeywordsTest.java

@@ -1,49 +1,49 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for CKeywords
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class CKeywordsTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("CKeywords.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void CKeywordsTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("char"));
-		raiseEvent("auto");
-		interpreter.runCycle();
-		assertTrue(isActive("const"));
-		assertTrue(isActive("case"));
-		assertTrue(isActive("asm"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for CKeywords
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class CKeywordsTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("CKeywords.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void CKeywordsTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("char"));
+		raiseEvent("auto");
+		interpreter.runCycle();
+		assertTrue(isActive("const"));
+		assertTrue(isActive("case"));
+		assertTrue(isActive("asm"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/ChoiceTest.java

@@ -1,101 +1,101 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for Choice
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class ChoiceTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models.loadExecutionFlowFromResource("Choice.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void elseChoiceUsingNonDefaultTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		setBoolean("c", true);
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-	}
-	@Test
-	public void elseChoiceUsingDefaultTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		setBoolean("c", false);
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-	}
-	@Test
-	public void defaultChoiceUsingNonDefaultTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		setBoolean("c", true);
-		raiseEvent("g");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-	}
-	@Test
-	public void defaultChoiceUsingDefaultTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		setBoolean("c", false);
-		raiseEvent("g");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-	}
-	@Test
-	public void uncheckedChoiceUsingNonDefaultTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		setBoolean("c", true);
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-	}
-	@Test
-	public void uncheckedChoiceUsingDefaultTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		setBoolean("c", false);
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-	}
-	@Test
-	public void alwaysTrueTransitionInChoice() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		setBoolean("c", true);
-		raiseEvent("h");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for Choice
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class ChoiceTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models.loadExecutionFlowFromResource("Choice.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void elseChoiceUsingNonDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", true);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+	}
+	@Test
+	public void elseChoiceUsingDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", false);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+	}
+	@Test
+	public void defaultChoiceUsingNonDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", true);
+		raiseEvent("g");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+	}
+	@Test
+	public void defaultChoiceUsingDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", false);
+		raiseEvent("g");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+	}
+	@Test
+	public void uncheckedChoiceUsingNonDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", true);
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+	}
+	@Test
+	public void uncheckedChoiceUsingDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", false);
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+	}
+	@Test
+	public void alwaysTrueTransitionInChoice() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", true);
+		raiseEvent("h");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/DeclarationsTest.java

@@ -1,43 +1,43 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for Declarations
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class DeclarationsTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("Declarations.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void declarationsTest() throws Exception {
-		interpreter.enter();
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for Declarations
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class DeclarationsTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("Declarations.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void declarationsTest() throws Exception {
+		interpreter.enter();
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/DeepHistoryTest.java

@@ -1,61 +1,61 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for DeepHistory
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class DeepHistoryTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("DeepHistory.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void deepHistoryTest() throws Exception {
-		interpreter.enter();
-		raiseEvent("event1");
-		interpreter.runCycle();
-		raiseEvent("event3");
-		interpreter.runCycle();
-		raiseEvent("event5");
-		interpreter.runCycle();
-		raiseEvent("event7");
-		interpreter.runCycle();
-		assertTrue(!isActive("State1"));
-		assertTrue(isActive("State9"));
-		raiseEvent("event2");
-		interpreter.runCycle();
-		assertTrue(isActive("State1"));
-		assertTrue(!isActive("State9"));
-		raiseEvent("event1");
-		interpreter.runCycle();
-		assertTrue(!isActive("State1"));
-		assertTrue(isActive("State9"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for DeepHistory
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class DeepHistoryTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("DeepHistory.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void deepHistoryTest() throws Exception {
+		interpreter.enter();
+		raiseEvent("event1");
+		interpreter.runCycle();
+		raiseEvent("event3");
+		interpreter.runCycle();
+		raiseEvent("event5");
+		interpreter.runCycle();
+		raiseEvent("event7");
+		interpreter.runCycle();
+		assertTrue(!isActive("State1"));
+		assertTrue(isActive("State9"));
+		raiseEvent("event2");
+		interpreter.runCycle();
+		assertTrue(isActive("State1"));
+		assertTrue(!isActive("State9"));
+		raiseEvent("event1");
+		interpreter.runCycle();
+		assertTrue(!isActive("State1"));
+		assertTrue(isActive("State9"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/EnterStateTest.java

@@ -1,63 +1,63 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for EnterState
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class EnterStateTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("EnterState.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void defaultEntry() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("E"));
-	}
-	@Test
-	public void namedEntryThroughNamedTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("F"));
-	}
-	@Test
-	public void namedEntryThroughDefaultTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("g");
-		interpreter.runCycle();
-		assertTrue(isActive("E"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for EnterState
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class EnterStateTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("EnterState.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void defaultEntry() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("E"));
+	}
+	@Test
+	public void namedEntryThroughNamedTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("F"));
+	}
+	@Test
+	public void namedEntryThroughDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("g");
+		interpreter.runCycle();
+		assertTrue(isActive("E"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/ExitOnSelfTransitionTest.java

@@ -1,54 +1,54 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for ExitOnSelfTransition
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class ExitOnSelfTransitionTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("ExitOnSelfTransition.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void ExitOnSelfTransitionTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		assertTrue(getInteger("entryCount") == 1);
-		assertTrue(getInteger("exitCount") == 0);
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(getInteger("entryCount") == 2);
-		assertTrue(getInteger("exitCount") == 1);
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(getInteger("entryCount") == 2);
-		assertTrue(getInteger("exitCount") == 2);
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for ExitOnSelfTransition
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class ExitOnSelfTransitionTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("ExitOnSelfTransition.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void ExitOnSelfTransitionTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(getInteger("entryCount") == 1);
+		assertTrue(getInteger("exitCount") == 0);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(getInteger("entryCount") == 2);
+		assertTrue(getInteger("exitCount") == 1);
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(getInteger("entryCount") == 2);
+		assertTrue(getInteger("exitCount") == 2);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/ExitStateTest.java

@@ -1,70 +1,70 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for ExitState
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class ExitStateTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("ExitState.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void defaultExit() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("E"));
-	}
-	@Test
-	public void namedExitThroughNamedTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("F"));
-	}
-	@Test
-	public void namedExitThroughDefaultTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("g");
-		interpreter.runCycle();
-		assertTrue(isActive("E"));
-	}
-	@Test
-	public void remainInA() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for ExitState
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class ExitStateTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("ExitState.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void defaultExit() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("E"));
+	}
+	@Test
+	public void namedExitThroughNamedTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("F"));
+	}
+	@Test
+	public void namedExitThroughDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("g");
+		interpreter.runCycle();
+		assertTrue(isActive("E"));
+	}
+	@Test
+	public void remainInA() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/FeatureCallsTest.java

@@ -1,46 +1,46 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for FeatureCalls
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class FeatureCallsTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("FeatureCalls.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void FeatureCalls() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for FeatureCalls
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class FeatureCallsTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("FeatureCalls.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void FeatureCalls() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/GuardTest.java

@@ -1,58 +1,58 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for Guard
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class GuardTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models.loadExecutionFlowFromResource("Guard.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void guardTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("Event1");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		raiseEvent("Event2");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		raiseEvent("Return");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		raiseEvent("Event1");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		raiseEvent("Return");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for Guard
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class GuardTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models.loadExecutionFlowFromResource("Guard.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void guardTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("Event1");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		raiseEvent("Event2");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		raiseEvent("Return");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		raiseEvent("Event1");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		raiseEvent("Return");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/GuardedEntryTest.java

@@ -1,81 +1,81 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for GuardedEntry
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class GuardedEntryTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("GuardedEntry.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void EntryNotTakenOnStatechartEnter() throws Exception {
-		assertTrue(getBoolean("guard") == false);
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		assertTrue(getBoolean("done") == false);
-	}
-	@Test
-	public void EntryTakenOnStatechartEnter() throws Exception {
-		setBoolean("guard", true);
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		assertTrue(getBoolean("done") == true);
-	}
-	@Test
-	public void EntryTakenInTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		setBoolean("guard", true);
-		setBoolean("done", false);
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(getBoolean("done"));
-	}
-	@Test
-	public void EntryNotTakenInTransition() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		setBoolean("guard", false);
-		setBoolean("done", false);
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(!getBoolean("done"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for GuardedEntry
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class GuardedEntryTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("GuardedEntry.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void EntryNotTakenOnStatechartEnter() throws Exception {
+		assertTrue(getBoolean("guard") == false);
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(getBoolean("done") == false);
+	}
+	@Test
+	public void EntryTakenOnStatechartEnter() throws Exception {
+		setBoolean("guard", true);
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(getBoolean("done") == true);
+	}
+	@Test
+	public void EntryTakenInTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		setBoolean("guard", true);
+		setBoolean("done", false);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(getBoolean("done"));
+	}
+	@Test
+	public void EntryNotTakenInTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		setBoolean("guard", false);
+		setBoolean("done", false);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(!getBoolean("done"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/GuardedExitTest.java

@@ -1,59 +1,59 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for GuardedExit
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class GuardedExitTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("GuardedExit.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void ExitTaken() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		assertTrue(!getBoolean("guard"));
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(!getBoolean("done"));
-	}
-	@Test
-	public void ExitNotTaken() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		setBoolean("guard", true);
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(getBoolean("done"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for GuardedExit
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class GuardedExitTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("GuardedExit.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void ExitTaken() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(!getBoolean("guard"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(!getBoolean("done"));
+	}
+	@Test
+	public void ExitNotTaken() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("guard", true);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(getBoolean("done"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/HistoryWithoutInitialStepTest.java

@@ -1,80 +1,80 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for HistoryWithoutInitialStep
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class HistoryWithoutInitialStepTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("HistoryWithoutInitialStep.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void enterThroughInitialEntry() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-		raiseEvent("e2");
-		interpreter.runCycle();
-		assertTrue(isActive("D"));
-	}
-	@Test
-	public void enterCThroughHistory() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		raiseEvent("e2");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-	}
-	@Test
-	public void enterDThroughHistory() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("e1");
-		interpreter.runCycle();
-		raiseEvent("e2");
-		interpreter.runCycle();
-		assertTrue(isActive("D"));
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		raiseEvent("e2");
-		interpreter.runCycle();
-		assertTrue(isActive("D"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for HistoryWithoutInitialStep
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class HistoryWithoutInitialStepTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("HistoryWithoutInitialStep.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void enterThroughInitialEntry() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("D"));
+	}
+	@Test
+	public void enterCThroughHistory() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+	}
+	@Test
+	public void enterDThroughHistory() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("D"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("D"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/InEventLifeCycleTest.java

@@ -1,47 +1,47 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for InEventLifeCycle
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class InEventLifeCycleTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("InEventLifeCycle.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void eventLifeCycle() throws Exception {
-		interpreter.enter();
-		raiseEvent("e");
-		assertTrue(getInteger("i") == 0);
-		interpreter.runCycle();
-		assertTrue(getInteger("i") == 1);
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for InEventLifeCycle
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class InEventLifeCycleTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("InEventLifeCycle.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void eventLifeCycle() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		assertTrue(getInteger("i") == 0);
+		interpreter.runCycle();
+		assertTrue(getInteger("i") == 1);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/IntegerExpressionsTest.java

@@ -1,65 +1,65 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for IntegerExpressions
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class IntegerExpressionsTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("IntegerExpressions.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void integerExpressions() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("StateA"));
-		assertTrue(getInteger("myInt1") == 10);
-		assertTrue(getInteger("myInt2") == 5);
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(getBoolean("less") == false);
-		assertTrue(getBoolean("greater") == true);
-		assertTrue(getBoolean("equalOrLess") == false);
-		assertTrue(getBoolean("equalOrGreater") == true);
-		assertTrue(getBoolean("equal") == false);
-		assertTrue(getBoolean("notEqual") == true);
-		assertTrue(getInteger("plus") == 15);
-		assertTrue(getInteger("minus") == 5);
-		assertTrue(getInteger("multiply") == 50);
-		assertTrue(getInteger("division") == 2);
-		assertTrue(getInteger("modulo") == 0);
-		assertTrue(getInteger("negat") == -10);
-		assertTrue(getInteger("multiAssign") == 20);
-		assertTrue(getInteger("divAssign") == 2);
-		assertTrue(getInteger("plusAssign") == 12);
-		assertTrue(getInteger("minusAssign") == -8);
-		assertTrue(getInteger("moduloAssign") == 0);
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for IntegerExpressions
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class IntegerExpressionsTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("IntegerExpressions.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void integerExpressions() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		assertTrue(getInteger("myInt1") == 10);
+		assertTrue(getInteger("myInt2") == 5);
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(getBoolean("less") == false);
+		assertTrue(getBoolean("greater") == true);
+		assertTrue(getBoolean("equalOrLess") == false);
+		assertTrue(getBoolean("equalOrGreater") == true);
+		assertTrue(getBoolean("equal") == false);
+		assertTrue(getBoolean("notEqual") == true);
+		assertTrue(getInteger("plus") == 15);
+		assertTrue(getInteger("minus") == 5);
+		assertTrue(getInteger("multiply") == 50);
+		assertTrue(getInteger("division") == 2);
+		assertTrue(getInteger("modulo") == 0);
+		assertTrue(getInteger("negat") == -10);
+		assertTrue(getInteger("multiAssign") == 20);
+		assertTrue(getInteger("divAssign") == 2);
+		assertTrue(getInteger("plusAssign") == 12);
+		assertTrue(getInteger("minusAssign") == -8);
+		assertTrue(getInteger("moduloAssign") == 0);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/InternalEventLifeCycleTest.java

@@ -1,59 +1,59 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for InternalEventLifeCycle
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class InternalEventLifeCycleTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("InternalEventLifeCycle.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void InternalEventLifeCycleTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("C"));
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("D"));
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("D"));
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("C"));
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("C"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for InternalEventLifeCycle
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class InternalEventLifeCycleTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("InternalEventLifeCycle.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void InternalEventLifeCycleTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(isActive("C"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(isActive("D"));
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(isActive("D"));
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(isActive("C"));
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(isActive("C"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/NamedInterfaceAccessTest.java

@@ -1,51 +1,51 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for NamedInterfaceAccess
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class NamedInterfaceAccessTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("NamedInterfaceAccess.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void SafeOpenSuccess() throws Exception {
-		interpreter.enter();
-		interpreter.runCycle();
-		raiseEvent("User.numberPressed", 3);
-		interpreter.runCycle();
-		raiseEvent("User.numberPressed", 7);
-		interpreter.runCycle();
-		raiseEvent("User.numberPressed", 5);
-		interpreter.runCycle();
-		assertTrue(isRaised("Safe.open"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for NamedInterfaceAccess
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class NamedInterfaceAccessTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("NamedInterfaceAccess.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void SafeOpenSuccess() throws Exception {
+		interpreter.enter();
+		interpreter.runCycle();
+		raiseEvent("User.numberPressed", 3);
+		interpreter.runCycle();
+		raiseEvent("User.numberPressed", 7);
+		interpreter.runCycle();
+		raiseEvent("User.numberPressed", 5);
+		interpreter.runCycle();
+		assertTrue(isRaised("Safe.open"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/OutEventLifeCycleTest.java

@@ -1,69 +1,69 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for OutEventLifeCycle
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class OutEventLifeCycleTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("OutEventLifeCycle.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void availableAfterCycle() throws Exception {
-		interpreter.enter();
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isRaised("f"));
-	}
-	@Test
-	public void availableWithinCycle() throws Exception {
-		interpreter.enter();
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(getBoolean("f_available_in_cycle"));
-	}
-	@Test
-	public void unvailableWithin2ndCycle() throws Exception {
-		interpreter.enter();
-		raiseEvent("e");
-		interpreter.runCycle();
-		interpreter.runCycle();
-		assertTrue(!getBoolean("f_available_in_next_cycle"));
-	}
-	@Test
-	public void unvailableAfter2ndCycle() throws Exception {
-		interpreter.enter();
-		raiseEvent("e");
-		interpreter.runCycle();
-		interpreter.runCycle();
-		assertTrue(!isRaised("f"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for OutEventLifeCycle
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class OutEventLifeCycleTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("OutEventLifeCycle.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void availableAfterCycle() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isRaised("f"));
+	}
+	@Test
+	public void availableWithinCycle() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(getBoolean("f_available_in_cycle"));
+	}
+	@Test
+	public void unvailableWithin2ndCycle() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		interpreter.runCycle();
+		interpreter.runCycle();
+		assertTrue(!getBoolean("f_available_in_next_cycle"));
+	}
+	@Test
+	public void unvailableAfter2ndCycle() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		interpreter.runCycle();
+		interpreter.runCycle();
+		assertTrue(!isRaised("f"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/ParenthesisTest.java

@@ -1,45 +1,45 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for Parenthesis
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class ParenthesisTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("Parenthesis.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void simple() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		assertTrue(getInteger("erg") == 8);
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for Parenthesis
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class ParenthesisTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("Parenthesis.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void simple() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(getInteger("erg") == 8);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/PriorityValuesTest.java

@@ -1,56 +1,56 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for PriorityValues
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class PriorityValuesTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("PriorityValues.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void transitionPriority() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("event1");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-	}
-	@Test
-	public void regionPriority() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("event2");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(!isActive("E"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for PriorityValues
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class PriorityValuesTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("PriorityValues.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void transitionPriority() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("event1");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+	}
+	@Test
+	public void regionPriority() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("event2");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(!isActive("E"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/RaiseEventTest.java

@@ -1,50 +1,50 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for RaiseEvent
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class RaiseEventTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("RaiseEvent.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void raiseEvent() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("SateA"));
-		assertTrue(isActive("StateA"));
-		raiseEvent("e2");
-		interpreter.runCycle();
-		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(isActive("StateB"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for RaiseEvent
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class RaiseEventTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("RaiseEvent.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void raiseEvent() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("SateA"));
+		assertTrue(isActive("StateA"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		assertTrue(isActive("StateB"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/SameNameDifferentRegionTest.java

@@ -1,52 +1,52 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for SameNameDifferentRegion
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class SameNameDifferentRegionTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("SameNameDifferentRegion.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void sameNameDifferenRegionTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("StateA"));
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(isActive("StateA"));
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(isActive("StateB"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for SameNameDifferentRegion
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class SameNameDifferentRegionTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("SameNameDifferentRegion.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void sameNameDifferenRegionTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		assertTrue(isActive("StateA"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		assertTrue(isActive("StateB"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/ShallowHistoryTest.java

@@ -1,73 +1,73 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for ShallowHistory
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class ShallowHistoryTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("ShallowHistory.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void shallowHistoryTest() throws Exception {
-		interpreter.enter();
-		raiseEvent("event1");
-		interpreter.runCycle();
-		raiseEvent("event3");
-		interpreter.runCycle();
-		raiseEvent("event5");
-		interpreter.runCycle();
-		raiseEvent("event7");
-		interpreter.runCycle();
-		assertTrue(!isActive("State1"));
-		assertTrue(isActive("State9"));
-		raiseEvent("event6");
-		interpreter.runCycle();
-		assertTrue(!isActive("State9"));
-		assertTrue(isActive("State6"));
-		raiseEvent("event5");
-		interpreter.runCycle();
-		assertTrue(!isActive("State8"));
-		assertTrue(isActive("State9"));
-		raiseEvent("event2");
-		interpreter.runCycle();
-		assertTrue(!isActive("State9"));
-		assertTrue(isActive("State1"));
-		raiseEvent("event1");
-		interpreter.runCycle();
-		assertTrue(isActive("State6"));
-		assertTrue(!isActive("State1"));
-		raiseEvent("event5");
-		interpreter.runCycle();
-		assertTrue(!isActive("State6"));
-		assertTrue(isActive("State9"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for ShallowHistory
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class ShallowHistoryTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("ShallowHistory.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void shallowHistoryTest() throws Exception {
+		interpreter.enter();
+		raiseEvent("event1");
+		interpreter.runCycle();
+		raiseEvent("event3");
+		interpreter.runCycle();
+		raiseEvent("event5");
+		interpreter.runCycle();
+		raiseEvent("event7");
+		interpreter.runCycle();
+		assertTrue(!isActive("State1"));
+		assertTrue(isActive("State9"));
+		raiseEvent("event6");
+		interpreter.runCycle();
+		assertTrue(!isActive("State9"));
+		assertTrue(isActive("State6"));
+		raiseEvent("event5");
+		interpreter.runCycle();
+		assertTrue(!isActive("State8"));
+		assertTrue(isActive("State9"));
+		raiseEvent("event2");
+		interpreter.runCycle();
+		assertTrue(!isActive("State9"));
+		assertTrue(isActive("State1"));
+		raiseEvent("event1");
+		interpreter.runCycle();
+		assertTrue(isActive("State6"));
+		assertTrue(!isActive("State1"));
+		raiseEvent("event5");
+		interpreter.runCycle();
+		assertTrue(!isActive("State6"));
+		assertTrue(isActive("State9"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/SimpleEventTest.java

@@ -1,48 +1,48 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for SimpleEvent
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class SimpleEventTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("SimpleEvent.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void simpleEventTest() throws Exception {
-		interpreter.enter();
-		assertTrue("Expected A to be active", isActive("A"));
-		assertTrue(5 == 5);
-		raiseEvent("Event1");
-		interpreter.runCycle();
-		assertTrue("Expected B to be active", isActive("B"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for SimpleEvent
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class SimpleEventTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("SimpleEvent.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void simpleEventTest() throws Exception {
+		interpreter.enter();
+		assertTrue("Expected A to be active", isActive("A"));
+		assertTrue(5 == 5);
+		raiseEvent("Event1");
+		interpreter.runCycle();
+		assertTrue("Expected B to be active", isActive("B"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/SimpleHierachyTest.java

@@ -1,50 +1,50 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for SimpleHierachy
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class SimpleHierachyTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("SimpleHierachy.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void simpleHierachyTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("Event1");
-		raiseEvent("Event1");
-		raiseEvent("Event1");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("B1"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for SimpleHierachy
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class SimpleHierachyTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("SimpleHierachy.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void simpleHierachyTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("Event1");
+		raiseEvent("Event1");
+		raiseEvent("Event1");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(isActive("B1"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/StateIsActiveTest.java

@@ -1,50 +1,50 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for StateIsActive
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class StateIsActiveTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("StateIsActive.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void stateIsActive() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("R1A"));
-		assertTrue(isActive("R2A"));
-		raiseEvent("Event1");
-		interpreter.runCycle();
-		interpreter.runCycle();
-		assertTrue(isActive("R1B"));
-		assertTrue(isActive("R2B"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for StateIsActive
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class StateIsActiveTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("StateIsActive.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void stateIsActive() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("R1A"));
+		assertTrue(isActive("R2A"));
+		raiseEvent("Event1");
+		interpreter.runCycle();
+		interpreter.runCycle();
+		assertTrue(isActive("R1B"));
+		assertTrue(isActive("R2B"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/StatechartLocalReactionsTest.java

@@ -1,54 +1,54 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for StatechartLocalReactions
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class StatechartLocalReactionsTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("StatechartLocalReactions.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void statechartLocalReactionsTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("S1"));
-		assertTrue(isActive("a"));
-		while (getInteger("myInt") < 10) {
-			assertTrue(isActive("a"));
-			if (getInteger("myInt") % 2 == 0) {
-				assertTrue(isActive("S1"));;
-			} else {
-				assertTrue(isActive("S2"));;
-			}
-			interpreter.runCycle();
-		}
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for StatechartLocalReactions
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class StatechartLocalReactionsTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("StatechartLocalReactions.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void statechartLocalReactionsTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("S1"));
+		assertTrue(isActive("a"));
+		while (getInteger("myInt") < 10) {
+			assertTrue(isActive("a"));
+			if (getInteger("myInt") % 2 == 0) {
+				assertTrue(isActive("S1"));;
+			} else {
+				assertTrue(isActive("S2"));;
+			}
+			interpreter.runCycle();
+		}
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/StringExpressionsTest.java

@@ -1,54 +1,54 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for StringExpressions
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class StringExpressionsTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("StringExpressions.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void StringExpressionsTest() throws Exception {
-		assertTrue(getString("quotedString").equals("\"x\""));
-		interpreter.enter();
-		assertTrue(isActive("StateA"));
-		assertTrue(getString("myString").equals("hello"));
-		assertTrue(getString("myString2").equals("world"));
-		assertTrue(getString("quotedString").equals("'y'"));
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(getBoolean("equals") == false);
-		assertTrue(getBoolean("notEqual") == true);
-		assertTrue(getString("quotedString").equals("\"z\""));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for StringExpressions
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class StringExpressionsTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("StringExpressions.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void StringExpressionsTest() throws Exception {
+		assertTrue(getString("quotedString").equals("\"x\""));
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		assertTrue(getString("myString").equals("hello"));
+		assertTrue(getString("myString2").equals("world"));
+		assertTrue(getString("quotedString").equals("'y'"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		assertTrue(getBoolean("equals") == false);
+		assertTrue(getBoolean("notEqual") == true);
+		assertTrue(getString("quotedString").equals("\"z\""));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/SyncForkTest.java

@@ -1,62 +1,62 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for SyncFork
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class SyncForkTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("SyncFork.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void syncForkTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D1"));
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D1"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for SyncFork
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class SyncForkTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("SyncFork.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void syncForkTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(isActive("C1"));
+		assertTrue(isActive("D1"));
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(isActive("C2"));
+		assertTrue(isActive("D2"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(isActive("C1"));
+		assertTrue(isActive("D1"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/SyncJoinTest.java

@@ -1,119 +1,119 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for SyncJoin
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class SyncJoinTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("SyncJoin.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void syncJoin_C2_Waits() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D1"));
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D1"));
-		raiseEvent("jc");
-		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D1"));
-		raiseEvent("jd");
-		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D1"));
-		raiseEvent("jc");
-		raiseEvent("jd");
-		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D1"));
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
-		raiseEvent("jc");
-		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
-		raiseEvent("jd");
-		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
-		raiseEvent("jc");
-		raiseEvent("jd");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-	}
-	@Test
-	public void syncJoin_D2_Waits() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D1"));
-		raiseEvent("f");
-		interpreter.runCycle();
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D2"));
-		raiseEvent("jc");
-		interpreter.runCycle();
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D2"));
-		raiseEvent("jd");
-		interpreter.runCycle();
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D2"));
-		raiseEvent("jc");
-		raiseEvent("jd");
-		interpreter.runCycle();
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D2"));
-		raiseEvent("e");
-		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
-	}
-	@Test
-	public void doubleEntryActionBug() throws Exception {
-		interpreter.enter();
-		raiseEvent("e");
-		raiseEvent("f");
-		interpreter.runCycle();
-		raiseEvent("jc");
-		raiseEvent("jd");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(getInteger("x") == 1);
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for SyncJoin
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class SyncJoinTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("SyncJoin.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void syncJoin_C2_Waits() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("B"));
+		assertTrue(isActive("C1"));
+		assertTrue(isActive("D1"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("C2"));
+		assertTrue(isActive("D1"));
+		raiseEvent("jc");
+		interpreter.runCycle();
+		assertTrue(isActive("C2"));
+		assertTrue(isActive("D1"));
+		raiseEvent("jd");
+		interpreter.runCycle();
+		assertTrue(isActive("C2"));
+		assertTrue(isActive("D1"));
+		raiseEvent("jc");
+		raiseEvent("jd");
+		interpreter.runCycle();
+		assertTrue(isActive("C2"));
+		assertTrue(isActive("D1"));
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("C2"));
+		assertTrue(isActive("D2"));
+		raiseEvent("jc");
+		interpreter.runCycle();
+		assertTrue(isActive("C2"));
+		assertTrue(isActive("D2"));
+		raiseEvent("jd");
+		interpreter.runCycle();
+		assertTrue(isActive("C2"));
+		assertTrue(isActive("D2"));
+		raiseEvent("jc");
+		raiseEvent("jd");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+	}
+	@Test
+	public void syncJoin_D2_Waits() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("B"));
+		assertTrue(isActive("C1"));
+		assertTrue(isActive("D1"));
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("C1"));
+		assertTrue(isActive("D2"));
+		raiseEvent("jc");
+		interpreter.runCycle();
+		assertTrue(isActive("C1"));
+		assertTrue(isActive("D2"));
+		raiseEvent("jd");
+		interpreter.runCycle();
+		assertTrue(isActive("C1"));
+		assertTrue(isActive("D2"));
+		raiseEvent("jc");
+		raiseEvent("jd");
+		interpreter.runCycle();
+		assertTrue(isActive("C1"));
+		assertTrue(isActive("D2"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("C2"));
+		assertTrue(isActive("D2"));
+	}
+	@Test
+	public void doubleEntryActionBug() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		raiseEvent("f");
+		interpreter.runCycle();
+		raiseEvent("jc");
+		raiseEvent("jd");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(getInteger("x") == 1);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/TransitionWithoutConditionTest.java

@@ -1,46 +1,46 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for TransitionWithoutCondition
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class TransitionWithoutConditionTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("TransitionWithoutCondition.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void TransitionWithoutConditionTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for TransitionWithoutCondition
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class TransitionWithoutConditionTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("TransitionWithoutCondition.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void TransitionWithoutConditionTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/test-gen/org/yakindu/sct/model/sexec/interpreter/test/ValuedEventsTest.java

@@ -1,47 +1,47 @@
-/**
- * Copyright (c) 2013 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.model.sexec.interpreter.test;
-import org.eclipse.xtext.junit4.InjectWith;
-import org.eclipse.xtext.junit4.XtextRunner;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
-import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
-import com.google.inject.Inject;
-import org.junit.Before;
-import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
-import org.yakindu.sct.model.sexec.ExecutionFlow;
-import org.yakindu.sct.test.models.SCTUnitTestModels;
-import static junit.framework.Assert.*;
-/**
- *  Unit TestCase for ValuedEvents
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class ValuedEventsTest extends AbstractExecutionFlowTest {
-	@Inject
-	private SCTUnitTestModels models;
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("ValuedEvents.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void valuedEventsTest() throws Exception {
-		interpreter.enter();
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("C"));
-		assertTrue(getInteger("myVar") == 42);
-	}
-}
+/**
+ * Copyright (c) 2013 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.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for ValuedEvents
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class ValuedEventsTest extends AbstractExecutionFlowTest {
+	@Inject
+	private SCTUnitTestModels models;
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("ValuedEvents.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void valuedEventsTest() throws Exception {
+		interpreter.enter();
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(isActive("C"));
+		assertTrue(getInteger("myVar") == 42);
+	}
+}