added functionality to Interpreter-engine for isActive and isFinal

Changed API for isActive(state) to isStateActive(state)

test-plugins/org.yakindu.sct.simulation.core.sexec.test/model/test.sgen

@@ -169,6 +169,14 @@ GeneratorModel for sctunit::interpreter {
 		}			
 	}
 	
+	test FinalState{
+		
+		feature Outlet{ 
+			targetProject = "org.yakindu.sct.simulation.core.sexec.test" 
+			targetFolder = "test-gen"			
+		}			
+	}
+	
 	test Guard{
 		
 		feature Outlet{ 

test-plugins/org.yakindu.sct.simulation.core.sexec.test/src/org/yakindu/sct/model/sexec/interpreter/test/InterpreterOperationsTest.java

@@ -39,20 +39,20 @@ public class InterpreterOperationsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void operationsSimpleTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 	}
 
 	@Test
 	public void operationsExtendedTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		assertTrue(getBoolean("myBool") == true);
 		raiseEvent("ev");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/src/org/yakindu/sct/model/sexec/interpreter/test/util/AbstractExecutionFlowTest.java

@@ -17,6 +17,9 @@ import java.util.List;
 
 import org.eclipse.core.runtime.Assert;
 import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.model.sexec.ExecutionState;
+import org.yakindu.sct.model.sexec.extensions.StateVectorExtensions;
+import org.yakindu.sct.model.sgraph.FinalState;
 import org.yakindu.sct.model.sgraph.RegularState;
 import org.yakindu.sct.simulation.core.sexec.container.IExecutionContextInitializer;
 import org.yakindu.sct.simulation.core.sexec.interpreter.IExecutionFlowInterpreter;
@@ -40,14 +43,23 @@ public abstract class AbstractExecutionFlowTest {
 	protected ExecutionContext context;
 	@Inject
 	protected IExecutionContextInitializer initializer;
+	@Inject
+	protected StateVectorExtensions stateVectorExtensions;
+
+	protected ExecutionFlow flow;
 
 	protected ExecutionContext context() {
 		return context;
 	}
 
+	protected ExecutionFlow flow() {
+		return flow;
+	}
+	
 	protected void initInterpreter(ExecutionFlow flow) {
 		initializer.initialize(context, flow);
 		interpreter.initialize(flow, context);
+		this.flow = flow;
 	}
 
 	protected long getInteger(String varName) {
@@ -93,12 +105,11 @@ public abstract class AbstractExecutionFlowTest {
 	// -> Assertion methods...
 	protected void assertVarValue(String variableName, Object value) {
 		ExecutionVariable variable = context().getVariable(variableName);
-		assertNotNull("Variable '" + variableName + "' is not defined",
-				variable);
+		assertNotNull("Variable '" + variableName + "' is not defined", variable);
 		assertEquals(value, variable.getValue());
 	}
 
-	protected boolean isActive(String stateName) {
+	protected boolean isStateActive(String stateName) {
 		Assert.isNotNull(stateName);
 		List<RegularState> allActiveStates = context().getAllActiveStates();
 		for (RegularState regularState : allActiveStates) {
@@ -123,4 +134,29 @@ public abstract class AbstractExecutionFlowTest {
 		return context().getEvent(eventName).isRaised();
 	}
 
+	protected boolean isActive() {
+		List<RegularState> activeStates = context.getAllActiveStates();
+		for (RegularState regularState : activeStates) {
+			if (!(regularState instanceof FinalState)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	protected boolean isFinal() {
+		List<ExecutionState>[] list = stateVectorExtensions.finalStateImpactVector(flow);
+		boolean isCompletlyCovered = stateVectorExtensions.isCompletelyCovered(list);
+		if (!isCompletlyCovered) {
+			return false;
+		} else {
+			List<RegularState> activeStates = context.getAllActiveStates();
+			for (RegularState regularState : activeStates) {
+				if (!(regularState instanceof FinalState)) {
+					return false;
+				}
+			}
+			return true;
+		}
+	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/AllTestsTest.java

@@ -23,8 +23,8 @@ import org.junit.runners.Suite.SuiteClasses;
 		DynamicChoiceTest.class, EmptyTransitionTest.class,
 		EnterStateTest.class, EntryChoiceTest.class,
 		EntryExitSelfTransitionTest.class, ExitOnSelfTransitionTest.class,
-		ExitStateTest.class, FeatureCallsTest.class, GuardTest.class,
-		GuardedEntryTest.class, GuardedExitTest.class,
+		ExitStateTest.class, FeatureCallsTest.class, FinalStateTest.class,
+		GuardTest.class, GuardedEntryTest.class, GuardedExitTest.class,
 		HistoryWithExitPointTest.class, HistoryWithoutInitialStepTest.class,
 		InEventLifeCycleTest.class, IntegerExpressionsTest.class,
 		InternalEventLifeCycleTest.class, LocalReactionsTest.class,

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/AlwaysOncycleTest.java

@@ -36,18 +36,18 @@ public class AlwaysOncycleTest extends AbstractExecutionFlowTest {
 	@Test
 	public void alwaysOncycleTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("StateA"));
+		assertTrue(isStateActive("StateA"));
 		while (getInteger("value") < 5l) {
 			interpreter.runCycle();
-			assertTrue(isActive("StateA"));
+			assertTrue(isStateActive("StateA"));
 		}
 		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
+		assertTrue(isStateActive("StateB"));
 		while (getInteger("value") < 5l) {
 			interpreter.runCycle();
-			assertTrue(isActive("StateB"));
+			assertTrue(isStateActive("StateB"));
 		}
 		interpreter.runCycle();
-		assertTrue(isActive("StateA"));
+		assertTrue(isStateActive("StateA"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/AssignmentAsExpressionTest.java

@@ -36,33 +36,33 @@ public class AssignmentAsExpressionTest extends AbstractExecutionFlowTest {
 	@Test
 	public void simpleAssignment() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("Add"));
+		assertTrue(isStateActive("Add"));
 		assertTrue(getInteger("b") == 5l);
 		assertTrue(getInteger("a") == 9l);
 		interpreter.runCycle();
-		assertTrue(isActive("Subtract"));
+		assertTrue(isStateActive("Subtract"));
 		assertTrue(getInteger("d") == 6l);
 		interpreter.runCycle();
-		assertTrue(isActive("Multiply"));
+		assertTrue(isStateActive("Multiply"));
 		assertTrue(getInteger("e") == 15l);
 		interpreter.runCycle();
-		assertTrue(isActive("Divide"));
+		assertTrue(isStateActive("Divide"));
 		assertTrue(getInteger("g") == 1l);
 		interpreter.runCycle();
-		assertTrue(isActive("Modulo"));
+		assertTrue(isStateActive("Modulo"));
 		assertTrue(getInteger("i") == 1l);
 		interpreter.runCycle();
-		assertTrue(isActive("Shift"));
+		assertTrue(isStateActive("Shift"));
 		assertTrue(getInteger("j") == 16l);
 		assertTrue(getInteger("k") == 4l);
 		interpreter.runCycle();
-		assertTrue(isActive("boolean And"));
+		assertTrue(isStateActive("boolean And"));
 		assertTrue(getInteger("l") == 1l);
 		interpreter.runCycle();
-		assertTrue(isActive("boolean Or"));
+		assertTrue(isStateActive("boolean Or"));
 		assertTrue(getInteger("p") == 15l);
 		interpreter.runCycle();
-		assertTrue(isActive("boolean Xor"));
+		assertTrue(isStateActive("boolean Xor"));
 		assertTrue(getInteger("u") == 12l);
 		interpreter.exit();
 	}

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/BitExpressionsTest.java

@@ -36,12 +36,12 @@ public class BitExpressionsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void BitExpressions() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("StateA"));
+		assertTrue(isStateActive("StateA"));
 		assertTrue(getInteger("myBit1") == 5l);
 		assertTrue(getInteger("myBit2") == 7l);
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
+		assertTrue(isStateActive("StateB"));
 		assertTrue(getInteger("leftBitshift") == 10l);
 		assertTrue(getInteger("rightBitshift") == 2l);
 		assertTrue(getInteger("complementBitshift") == -6l);

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/BooleanExpressionsTest.java

@@ -36,12 +36,12 @@ public class BooleanExpressionsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void booleanExpressions() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("StateA"));
+		assertTrue(isStateActive("StateA"));
 		assertTrue(getBoolean("myBool1") == true);
 		assertTrue(getBoolean("myBool2") == false);
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
+		assertTrue(isStateActive("StateB"));
 		assertTrue(getBoolean("and") == false);
 		assertTrue(getBoolean("or") == true);
 		assertTrue(getBoolean("not") == false);

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/CKeywordsTest.java

@@ -36,11 +36,11 @@ public class CKeywordsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void CKeywordsTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("char"));
+		assertTrue(isStateActive("char"));
 		raiseEvent("auto");
 		interpreter.runCycle();
-		assertTrue(isActive("loop"));
-		assertTrue(isActive("case"));
-		assertTrue(isActive("asm"));
+		assertTrue(isStateActive("loop"));
+		assertTrue(isStateActive("case"));
+		assertTrue(isStateActive("asm"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/CastExpressionsTest.java

@@ -41,7 +41,7 @@ public class CastExpressionsTest extends AbstractExecutionFlowTest {
 		interpreter.runCycle();
 		assertTrue(getReal("realValue") == 15l);
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 		assertTrue(getReal("realValue") == 757l);
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/ChoiceTest.java

@@ -35,64 +35,64 @@ public class ChoiceTest extends AbstractExecutionFlowTest {
 	@Test
 	public void elseChoiceUsingNonDefaultTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		setBoolean("c", true);
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 	}
 	@Test
 	public void elseChoiceUsingDefaultTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		setBoolean("c", false);
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 	}
 	@Test
 	public void defaultChoiceUsingNonDefaultTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		setBoolean("c", true);
 		raiseEvent("g");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 	}
 	@Test
 	public void defaultChoiceUsingDefaultTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		setBoolean("c", false);
 		raiseEvent("g");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 	}
 	@Test
 	public void uncheckedChoiceUsingNonDefaultTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		setBoolean("c", true);
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 	}
 	@Test
 	public void uncheckedChoiceUsingDefaultTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		setBoolean("c", false);
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 	}
 	@Test
 	public void alwaysTrueTransitionInChoice() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		setBoolean("c", true);
 		raiseEvent("h");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/ConditionalExpressionTest.java

@@ -36,11 +36,11 @@ public class ConditionalExpressionTest extends AbstractExecutionFlowTest {
 	@Test
 	public void ConditionalExpressionTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(getInteger("condition") == 1l);
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		assertTrue(getInteger("condition") == 2l);
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/ConstantsTestsTest.java

@@ -36,7 +36,7 @@ public class ConstantsTestsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void constantDefinition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(getInteger("x") == 10l);
 		assertTrue(getInteger("y") == 20l);
 		assertTrue(getString("Named.y").equals("Hello World"));
@@ -45,11 +45,11 @@ public class ConstantsTestsTest extends AbstractExecutionFlowTest {
 		assertTrue(getInteger("result") == 20l);
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 		assertTrue(getInteger("result") == 100l);
 		raiseEvent("e2", getInteger("x"));
 		interpreter.runCycle();
 		assertTrue(getInteger("result") == 1000l);
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/DeepEntryTest.java

@@ -44,13 +44,13 @@ public class DeepEntryTest extends AbstractExecutionFlowTest {
 		assertTrue(getInteger("z") == 2l);
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("BB"));
+		assertTrue(isStateActive("BB"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("BB"));
+		assertTrue(isStateActive("BB"));
 		assertTrue(getInteger("y") == 1l);
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/DeepHistoryTest.java

@@ -44,15 +44,15 @@ public class DeepHistoryTest extends AbstractExecutionFlowTest {
 		interpreter.runCycle();
 		raiseEvent("event7");
 		interpreter.runCycle();
-		assertTrue(!isActive("State1"));
-		assertTrue(isActive("State9"));
+		assertTrue(!isStateActive("State1"));
+		assertTrue(isStateActive("State9"));
 		raiseEvent("event2");
 		interpreter.runCycle();
-		assertTrue(isActive("State1"));
-		assertTrue(!isActive("State9"));
+		assertTrue(isStateActive("State1"));
+		assertTrue(!isStateActive("State9"));
 		raiseEvent("event1");
 		interpreter.runCycle();
-		assertTrue(!isActive("State1"));
-		assertTrue(isActive("State9"));
+		assertTrue(!isStateActive("State1"));
+		assertTrue(isStateActive("State9"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/DynamicChoiceTest.java

@@ -36,8 +36,8 @@ public class DynamicChoiceTest extends AbstractExecutionFlowTest {
 	@Test
 	public void DynamicChoiceTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("Start"));
+		assertTrue(isStateActive("Start"));
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/EmptyTransitionTest.java

@@ -37,7 +37,7 @@ public class EmptyTransitionTest extends AbstractExecutionFlowTest {
 	public void EmptyTransitionTest() throws Exception {
 		interpreter.enter();
 		interpreter.runCycle();
-		assertTrue(!isActive("B"));
-		assertTrue(isActive("A"));
+		assertTrue(!isStateActive("B"));
+		assertTrue(isStateActive("A"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/EnterStateTest.java

@@ -36,25 +36,25 @@ public class EnterStateTest extends AbstractExecutionFlowTest {
 	@Test
 	public void defaultEntry() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("E"));
+		assertTrue(isStateActive("E"));
 	}
 	@Test
 	public void namedEntryThroughNamedTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("F"));
+		assertTrue(isStateActive("F"));
 	}
 	@Test
 	public void namedEntryThroughDefaultTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("g");
 		interpreter.runCycle();
-		assertTrue(isActive("E"));
+		assertTrue(isStateActive("E"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/EntryChoiceTest.java

@@ -38,6 +38,6 @@ public class EntryChoiceTest extends AbstractExecutionFlowTest {
 		interpreter.enter();
 		interpreter.runCycle();
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/EntryExitSelfTransitionTest.java

@@ -38,13 +38,13 @@ public class EntryExitSelfTransitionTest extends AbstractExecutionFlowTest {
 		interpreter.enter();
 		interpreter.runCycle();
 		assertTrue(getInteger("entries") == 1l);
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		setInteger("entries", 0l);
 		raiseEvent("e");
 		interpreter.runCycle();
 		assertTrue(getInteger("entries") == 1l);
 		assertTrue(getInteger("exits") == 1l);
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 	}
 	@Test
 	public void SelfTransitionFromChildState() throws Exception {
@@ -56,10 +56,10 @@ public class EntryExitSelfTransitionTest extends AbstractExecutionFlowTest {
 		interpreter.runCycle();
 		assertTrue(getInteger("entries") == 0l);
 		assertTrue(getInteger("exits") == 0l);
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		assertTrue(getInteger("entries") == 1l);
 		assertTrue(getInteger("exits") == 1l);
 	}

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/ExitOnSelfTransitionTest.java

@@ -36,7 +36,7 @@ public class ExitOnSelfTransitionTest extends AbstractExecutionFlowTest {
 	@Test
 	public void ExitOnSelfTransitionTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(getInteger("entryCount") == 1l);
 		assertTrue(getInteger("exitCount") == 0l);
 		raiseEvent("e");

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/ExitStateTest.java

@@ -36,32 +36,32 @@ public class ExitStateTest extends AbstractExecutionFlowTest {
 	@Test
 	public void defaultExit() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("E"));
+		assertTrue(isStateActive("E"));
 	}
 	@Test
 	public void namedExitThroughNamedTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("F"));
+		assertTrue(isStateActive("F"));
 	}
 	@Test
 	public void namedExitThroughDefaultTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("g");
 		interpreter.runCycle();
-		assertTrue(isActive("E"));
+		assertTrue(isStateActive("E"));
 	}
 	@Test
 	public void remainInA() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/FeatureCallsTest.java

@@ -36,8 +36,8 @@ public class FeatureCallsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void FeatureCalls() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/FinalStateTest.java

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2015 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.simulation.core.sexec.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import com.google.inject.Inject;
+import static org.junit.Assert.assertTrue;
+/**
+ *  Unit TestCase for FinalState
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class FinalStateTest extends AbstractExecutionFlowTest {
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("FinalState.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void StatechartNameTest() throws Exception {
+		interpreter.enter();
+		interpreter.runCycle();
+		assertTrue(isFinal());
+	}
+}

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/GuardTest.java

@@ -35,21 +35,21 @@ public class GuardTest extends AbstractExecutionFlowTest {
 	@Test
 	public void guardTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("Event1");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("Event2");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		raiseEvent("Return");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("Event1");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		raiseEvent("Return");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/GuardedEntryTest.java

@@ -37,42 +37,42 @@ public class GuardedEntryTest extends AbstractExecutionFlowTest {
 	public void EntryNotTakenOnStatechartEnter() throws Exception {
 		assertTrue(getBoolean("guard") == false);
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(getBoolean("done") == false);
 	}
 	@Test
 	public void EntryTakenOnStatechartEnter() throws Exception {
 		setBoolean("guard", true);
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(getBoolean("done") == true);
 	}
 	@Test
 	public void EntryTakenInTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		setBoolean("guard", true);
 		setBoolean("done", false);
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(getBoolean("done"));
 	}
 	@Test
 	public void EntryNotTakenInTransition() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		setBoolean("guard", false);
 		setBoolean("done", false);
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(!getBoolean("done"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/GuardedExitTest.java

@@ -36,21 +36,21 @@ public class GuardedExitTest extends AbstractExecutionFlowTest {
 	@Test
 	public void ExitTaken() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(!getBoolean("guard"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		assertTrue(!getBoolean("done"));
 	}
 	@Test
 	public void ExitNotTaken() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		setBoolean("guard", true);
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		assertTrue(getBoolean("done"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/HistoryWithExitPointTest.java

@@ -36,21 +36,21 @@ public class HistoryWithExitPointTest extends AbstractExecutionFlowTest {
 	@Test
 	public void historyEntryAfterExit() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("X1"));
+		assertTrue(isStateActive("X1"));
 		raiseEvent("push");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		raiseEvent("back");
 		interpreter.runCycle();
-		assertTrue(isActive("X1"));
+		assertTrue(isStateActive("X1"));
 		raiseEvent("next");
 		interpreter.runCycle();
-		assertTrue(isActive("X2"));
+		assertTrue(isStateActive("X2"));
 		raiseEvent("push");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		raiseEvent("back");
 		interpreter.runCycle();
-		assertTrue(isActive("X2"));
+		assertTrue(isStateActive("X2"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/HistoryWithoutInitialStepTest.java

@@ -36,42 +36,42 @@ public class HistoryWithoutInitialStepTest extends AbstractExecutionFlowTest {
 	@Test
 	public void enterThroughInitialEntry() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("toB");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 		raiseEvent("next");
 		interpreter.runCycle();
-		assertTrue(isActive("D"));
+		assertTrue(isStateActive("D"));
 	}
 	@Test
 	public void enterCThroughHistory() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("toB");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 		raiseEvent("toA");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("toHistory");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 	}
 	@Test
 	public void enterDThroughHistory() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("toB");
 		interpreter.runCycle();
 		raiseEvent("next");
 		interpreter.runCycle();
-		assertTrue(isActive("D"));
+		assertTrue(isStateActive("D"));
 		raiseEvent("toA");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("toHistory");
 		interpreter.runCycle();
-		assertTrue(isActive("D"));
+		assertTrue(isStateActive("D"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/IntegerExpressionsTest.java

@@ -36,7 +36,7 @@ public class IntegerExpressionsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void integerExpressions() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("StateA"));
+		assertTrue(isStateActive("StateA"));
 		assertTrue(getInteger("myInt1") == 10l);
 		assertTrue(getInteger("myInt2") == 5l);
 		raiseEvent("e1");

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/InternalEventLifeCycleTest.java

@@ -36,21 +36,21 @@ public class InternalEventLifeCycleTest extends AbstractExecutionFlowTest {
 	@Test
 	public void InternalEventLifeCycleTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("A"));
+		assertTrue(isStateActive("C"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("D"));
+		assertTrue(isStateActive("A"));
+		assertTrue(isStateActive("D"));
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("D"));
+		assertTrue(isStateActive("A"));
+		assertTrue(isStateActive("D"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("A"));
+		assertTrue(isStateActive("C"));
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("A"));
+		assertTrue(isStateActive("C"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/LocalReactionsTest.java

@@ -36,7 +36,7 @@ public class LocalReactionsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void LocalReactionsTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		interpreter.runCycle();
 		assertTrue(getInteger("x") == 1l);
 	}

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/NullCheckTest.java

@@ -36,8 +36,8 @@ public class NullCheckTest extends AbstractExecutionFlowTest {
 	@Test
 	public void SimpleNullCheckTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/OperationsWithoutBracesTest.java

@@ -36,16 +36,16 @@ public class OperationsWithoutBracesTest extends AbstractExecutionFlowTest {
 	@Test
 	public void OperationsWithoutBracesTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
+		assertTrue(isStateActive("A"));
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
+		assertTrue(isStateActive("B"));
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
+		assertTrue(isStateActive("C"));
 		interpreter.runCycle();
-		assertTrue(isActive("D"));
-		assertTrue(isActive("D"));
+		assertTrue(isStateActive("D"));
+		assertTrue(isStateActive("D"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/ParenthesisTest.java

@@ -36,7 +36,7 @@ public class ParenthesisTest extends AbstractExecutionFlowTest {
 	@Test
 	public void simple() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(getInteger("erg") == 8l);
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/PriorityValuesTest.java

@@ -36,18 +36,18 @@ public class PriorityValuesTest extends AbstractExecutionFlowTest {
 	@Test
 	public void transitionPriority() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("event1");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
+		assertTrue(isStateActive("C"));
 	}
 	@Test
 	public void regionPriority() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("event2");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(!isActive("E"));
+		assertTrue(isStateActive("B"));
+		assertTrue(!isStateActive("E"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/RaiseEventTest.java

@@ -36,12 +36,12 @@ public class RaiseEventTest extends AbstractExecutionFlowTest {
 	@Test
 	public void raiseEvent() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("SateA"));
-		assertTrue(isActive("StateA"));
+		assertTrue(isStateActive("SateA"));
+		assertTrue(isStateActive("StateA"));
 		raiseEvent("e2");
 		interpreter.runCycle();
 		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(isActive("StateB"));
+		assertTrue(isStateActive("StateB"));
+		assertTrue(isStateActive("StateB"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/STextKeywordsInStatesAndRegionsTest.java

@@ -38,465 +38,465 @@ public class STextKeywordsInStatesAndRegionsTest
 	@Test
 	public void activeCheckWithSTextNamedStates() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("raise"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("raise"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("active"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("active"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("interface"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("interface"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("event"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("event"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("in"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("in"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("var"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("var"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("external"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("external"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("default"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("default"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("entry"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("entry"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("always"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("always"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("raise"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("raise"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
-		assertTrue(isActive("namespace"));
-		assertTrue(isActive("internal"));
-		assertTrue(isActive("local"));
-		assertTrue(isActive("out"));
-		assertTrue(isActive("readonly"));
-		assertTrue(isActive("operation"));
-		assertTrue(isActive("else"));
-		assertTrue(isActive("exit"));
-		assertTrue(isActive("oncycle"));
-		assertTrue(isActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
+		assertTrue(isStateActive("namespace"));
+		assertTrue(isStateActive("internal"));
+		assertTrue(isStateActive("local"));
+		assertTrue(isStateActive("out"));
+		assertTrue(isStateActive("readonly"));
+		assertTrue(isStateActive("operation"));
+		assertTrue(isStateActive("else"));
+		assertTrue(isStateActive("exit"));
+		assertTrue(isStateActive("oncycle"));
+		assertTrue(isStateActive("valueof"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/SameNameDifferentRegionTest.java

@@ -36,14 +36,14 @@ public class SameNameDifferentRegionTest extends AbstractExecutionFlowTest {
 	@Test
 	public void sameNameDifferenRegionTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("StateA"));
+		assertTrue(isStateActive("StateA"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(isActive("StateA"));
+		assertTrue(isStateActive("StateB"));
+		assertTrue(isStateActive("StateA"));
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(isActive("StateB"));
+		assertTrue(isStateActive("StateB"));
+		assertTrue(isStateActive("StateB"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/ShallowHistoryTest.java

@@ -44,27 +44,27 @@ public class ShallowHistoryTest extends AbstractExecutionFlowTest {
 		interpreter.runCycle();
 		raiseEvent("event7");
 		interpreter.runCycle();
-		assertTrue(!isActive("State1"));
-		assertTrue(isActive("State9"));
+		assertTrue(!isStateActive("State1"));
+		assertTrue(isStateActive("State9"));
 		raiseEvent("event6");
 		interpreter.runCycle();
-		assertTrue(!isActive("State9"));
-		assertTrue(isActive("State6"));
+		assertTrue(!isStateActive("State9"));
+		assertTrue(isStateActive("State6"));
 		raiseEvent("event5");
 		interpreter.runCycle();
-		assertTrue(!isActive("State8"));
-		assertTrue(isActive("State9"));
+		assertTrue(!isStateActive("State8"));
+		assertTrue(isStateActive("State9"));
 		raiseEvent("event2");
 		interpreter.runCycle();
-		assertTrue(!isActive("State9"));
-		assertTrue(isActive("State1"));
+		assertTrue(!isStateActive("State9"));
+		assertTrue(isStateActive("State1"));
 		raiseEvent("event1");
 		interpreter.runCycle();
-		assertTrue(isActive("State6"));
-		assertTrue(!isActive("State1"));
+		assertTrue(isStateActive("State6"));
+		assertTrue(!isStateActive("State1"));
 		raiseEvent("event5");
 		interpreter.runCycle();
-		assertTrue(!isActive("State6"));
-		assertTrue(isActive("State9"));
+		assertTrue(!isStateActive("State6"));
+		assertTrue(isStateActive("State9"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/ShallowHistoryWithDeepEntryTest.java

@@ -36,50 +36,50 @@ public class ShallowHistoryWithDeepEntryTest extends AbstractExecutionFlowTest {
 	@Test
 	public void noDeepEntryWithinHistory() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("Y"));
+		assertTrue(isStateActive("Y"));
 		raiseEvent("toZ");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("toY");
 		interpreter.runCycle();
-		assertTrue(isActive("Y"));
+		assertTrue(isStateActive("Y"));
 		raiseEvent("toZ");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 	}
 	@Test
 	public void deepEntryWithinHistory() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("Y"));
+		assertTrue(isStateActive("Y"));
 		raiseEvent("toZ");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("toC");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("C"));
+		assertTrue(isStateActive("B"));
 		raiseEvent("toY");
 		interpreter.runCycle();
-		assertTrue(isActive("Y"));
+		assertTrue(isStateActive("Y"));
 		raiseEvent("toZ");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("C"));
+		assertTrue(isStateActive("B"));
 	}
 	@Test
 	public void directDeepEntryIntoHistory() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("Y"));
+		assertTrue(isStateActive("Y"));
 		raiseEvent("toC");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("C"));
+		assertTrue(isStateActive("B"));
 		raiseEvent("toY");
 		interpreter.runCycle();
-		assertTrue(isActive("Y"));
+		assertTrue(isStateActive("Y"));
 		raiseEvent("toZ");
 		interpreter.runCycle();
-		assertTrue(isActive("C"));
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("C"));
+		assertTrue(isStateActive("B"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/SimpleEventTest.java

@@ -36,12 +36,12 @@ public class SimpleEventTest extends AbstractExecutionFlowTest {
 	@Test
 	public void simpleEventTest() throws Exception {
 		interpreter.enter();
-		assertTrue("Expected A to be active", isActive("A"));
+		assertTrue("Expected A to be active", isStateActive("A"));
 		assertTrue(5l == 5l);
 		raiseEvent("Event1");
 		interpreter.runCycle();
-		assertTrue("Expected B to be active", isActive("B"));
+		assertTrue("Expected B to be active", isStateActive("B"));
 		interpreter.runCycle();
-		assertTrue(!isActive("B"));
+		assertTrue(!isStateActive("B"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/SimpleHierachyTest.java

@@ -36,12 +36,12 @@ public class SimpleHierachyTest extends AbstractExecutionFlowTest {
 	@Test
 	public void simpleHierachyTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("Event1");
 		raiseEvent("Event1");
 		raiseEvent("Event1");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("B1"));
+		assertTrue(isStateActive("B"));
+		assertTrue(isStateActive("B1"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/StateIsActiveTest.java

@@ -36,12 +36,12 @@ public class StateIsActiveTest extends AbstractExecutionFlowTest {
 	@Test
 	public void stateIsActive() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("R1A"));
-		assertTrue(isActive("R2A"));
+		assertTrue(isStateActive("R1A"));
+		assertTrue(isStateActive("R2A"));
 		raiseEvent("Event1");
 		interpreter.runCycle();
 		interpreter.runCycle();
-		assertTrue(isActive("R1B"));
-		assertTrue(isActive("R2B"));
+		assertTrue(isStateActive("R1B"));
+		assertTrue(isStateActive("R2B"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/StatechartActiveTest.java

@@ -35,24 +35,24 @@ public class StatechartActiveTest extends AbstractExecutionFlowTest {
 	}
 	@Test
 	public void inactiveBeforeEnter() throws Exception {
-		assertTrue(false);
+		assertTrue(!isActive());
 	}
 	@Test
 	public void activeAfterEnter() throws Exception {
 		interpreter.enter();
-		assertTrue(false);
+		assertTrue(isActive());
 	}
 	@Test
 	public void inactiveAfterExit() throws Exception {
 		interpreter.enter();
 		interpreter.exit();
-		assertTrue(false);
+		assertTrue(!isActive());
 	}
 	@Test
 	public void activeAfterReenter() throws Exception {
 		interpreter.enter();
 		interpreter.exit();
 		interpreter.enter();
-		assertTrue(false);
+		assertTrue(isActive());
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/StatechartLocalReactionsTest.java

@@ -36,14 +36,14 @@ public class StatechartLocalReactionsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void statechartLocalReactionsTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("S1"));
-		assertTrue(isActive("a"));
+		assertTrue(isStateActive("S1"));
+		assertTrue(isStateActive("a"));
 		while (getInteger("myInt") < 10l) {
-			assertTrue(isActive("a"));
+			assertTrue(isStateActive("a"));
 			if (getInteger("myInt") % 2l == 0l) {
-				assertTrue(isActive("S1"));;
+				assertTrue(isStateActive("S1"));;
 			} else {
-				assertTrue(isActive("S2"));;
+				assertTrue(isStateActive("S2"));;
 			}
 			interpreter.runCycle();
 		}

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/StaticChoiceTest.java

@@ -36,7 +36,7 @@ public class StaticChoiceTest extends AbstractExecutionFlowTest {
 	@Test
 	public void StaticChoiceTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("Start"));
+		assertTrue(isStateActive("Start"));
 		interpreter.runCycle();
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/StringExpressionsTest.java

@@ -38,31 +38,31 @@ public class StringExpressionsTest extends AbstractExecutionFlowTest {
 		assertTrue(getString("quotedStringX").equals("\"X\""));
 		assertTrue(getString("quotedStringY").equals("\"Y\""));
 		interpreter.enter();
-		assertTrue(isActive("AssignmentChecked"));
+		assertTrue(isStateActive("AssignmentChecked"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("VarToVarCompareSucceeded"));
+		assertTrue(isStateActive("VarToVarCompareSucceeded"));
 		assertTrue(getBoolean("guardStringEqual"));
 		assertTrue(getBoolean("guardStringNotEqual"));
 		assertTrue(getBoolean("stringVarEqual"));
 		assertTrue(getBoolean("stringVarNotEqual"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("VarToConstCompareSucceeded"));
+		assertTrue(isStateActive("VarToConstCompareSucceeded"));
 		assertTrue(getBoolean("guardStringEqual"));
 		assertTrue(getBoolean("guardStringNotEqual"));
 		assertTrue(getBoolean("stringVarEqual"));
 		assertTrue(getBoolean("stringVarNotEqual"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("ConstToVarCompareSucceeded"));
+		assertTrue(isStateActive("ConstToVarCompareSucceeded"));
 		assertTrue(getBoolean("guardStringEqual"));
 		assertTrue(getBoolean("guardStringNotEqual"));
 		assertTrue(getBoolean("stringVarEqual"));
 		assertTrue(getBoolean("stringVarNotEqual"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("ConstToConstCompareSucceeded"));
+		assertTrue(isStateActive("ConstToConstCompareSucceeded"));
 		assertTrue(getBoolean("guardStringEqual"));
 		assertTrue(getBoolean("guardStringNotEqual"));
 		assertTrue(getBoolean("stringVarEqual"));

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/SyncForkTest.java

@@ -36,24 +36,24 @@ public class SyncForkTest extends AbstractExecutionFlowTest {
 	@Test
 	public void syncForkTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D1"));
+		assertTrue(isStateActive("B"));
+		assertTrue(isStateActive("C1"));
+		assertTrue(isStateActive("D1"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
+		assertTrue(isStateActive("B"));
+		assertTrue(isStateActive("C2"));
+		assertTrue(isStateActive("D2"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D1"));
+		assertTrue(isStateActive("B"));
+		assertTrue(isStateActive("C1"));
+		assertTrue(isStateActive("D1"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/SyncJoinTest.java

@@ -36,70 +36,70 @@ public class SyncJoinTest extends AbstractExecutionFlowTest {
 	@Test
 	public void syncJoin_C2_Waits() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D1"));
+		assertTrue(isStateActive("B"));
+		assertTrue(isStateActive("C1"));
+		assertTrue(isStateActive("D1"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D1"));
+		assertTrue(isStateActive("C2"));
+		assertTrue(isStateActive("D1"));
 		raiseEvent("jc");
 		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D1"));
+		assertTrue(isStateActive("C2"));
+		assertTrue(isStateActive("D1"));
 		raiseEvent("jd");
 		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D1"));
+		assertTrue(isStateActive("C2"));
+		assertTrue(isStateActive("D1"));
 		raiseEvent("jc");
 		raiseEvent("jd");
 		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D1"));
+		assertTrue(isStateActive("C2"));
+		assertTrue(isStateActive("D1"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
+		assertTrue(isStateActive("C2"));
+		assertTrue(isStateActive("D2"));
 		raiseEvent("jc");
 		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
+		assertTrue(isStateActive("C2"));
+		assertTrue(isStateActive("D2"));
 		raiseEvent("jd");
 		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
+		assertTrue(isStateActive("C2"));
+		assertTrue(isStateActive("D2"));
 		raiseEvent("jc");
 		raiseEvent("jd");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 	}
 	@Test
 	public void syncJoin_D2_Waits() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("B"));
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D1"));
+		assertTrue(isStateActive("B"));
+		assertTrue(isStateActive("C1"));
+		assertTrue(isStateActive("D1"));
 		raiseEvent("f");
 		interpreter.runCycle();
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D2"));
+		assertTrue(isStateActive("C1"));
+		assertTrue(isStateActive("D2"));
 		raiseEvent("jc");
 		interpreter.runCycle();
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D2"));
+		assertTrue(isStateActive("C1"));
+		assertTrue(isStateActive("D2"));
 		raiseEvent("jd");
 		interpreter.runCycle();
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D2"));
+		assertTrue(isStateActive("C1"));
+		assertTrue(isStateActive("D2"));
 		raiseEvent("jc");
 		raiseEvent("jd");
 		interpreter.runCycle();
-		assertTrue(isActive("C1"));
-		assertTrue(isActive("D2"));
+		assertTrue(isStateActive("C1"));
+		assertTrue(isStateActive("D2"));
 		raiseEvent("e");
 		interpreter.runCycle();
-		assertTrue(isActive("C2"));
-		assertTrue(isActive("D2"));
+		assertTrue(isStateActive("C2"));
+		assertTrue(isStateActive("D2"));
 	}
 	@Test
 	public void doubleEntryActionBug() throws Exception {
@@ -110,7 +110,7 @@ public class SyncJoinTest extends AbstractExecutionFlowTest {
 		raiseEvent("jc");
 		raiseEvent("jd");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		assertTrue(getInteger("x") == 1l);
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/TimedTransitionsTest.java

@@ -36,9 +36,9 @@ public class TimedTransitionsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void Timer01() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("Start"));
+		assertTrue(isStateActive("Start"));
 		Thread.sleep(2030);
 		interpreter.runCycle();
-		assertTrue(isActive("End"));
+		assertTrue(isStateActive("End"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/TransitionWithoutConditionTest.java

@@ -36,8 +36,8 @@ public class TransitionWithoutConditionTest extends AbstractExecutionFlowTest {
 	@Test
 	public void TransitionWithoutConditionTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/TriggerGuardExpressionsTest.java

@@ -36,37 +36,37 @@ public class TriggerGuardExpressionsTest extends AbstractExecutionFlowTest {
 	@Test
 	public void trueGuard() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("e1");
 		setBoolean("b", true);
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("e1");
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("B"));
+		assertTrue(isStateActive("B"));
 	}
 	@Test
 	public void falseGuard() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		setBoolean("b", false);
 		raiseEvent("e1");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 		raiseEvent("e1");
 		raiseEvent("e2");
 		interpreter.runCycle();
-		assertTrue(isActive("A"));
+		assertTrue(isStateActive("A"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/TypeAliasTest.java

@@ -36,15 +36,15 @@ public class TypeAliasTest extends AbstractExecutionFlowTest {
 	@Test
 	public void TypeAliasTest() throws Exception {
 		interpreter.enter();
-		assertTrue(isActive("Start"));
+		assertTrue(isStateActive("Start"));
 		assertTrue(getInteger("myVar") == 1l);
 		interpreter.runCycle();
-		assertTrue(isActive("Mid"));
+		assertTrue(isStateActive("Mid"));
 		assertTrue(getString("myString").equals("TypeSystem"));
 		interpreter.runCycle();
-		assertTrue(isActive("Mid2"));
+		assertTrue(isStateActive("Mid2"));
 		raiseEvent("myEvent");
 		interpreter.runCycle();
-		assertTrue(isActive("End"));
+		assertTrue(isStateActive("End"));
 	}
 }

test-plugins/org.yakindu.sct.simulation.core.sexec.test/test-gen/org/yakindu/sct/simulation/core/sexec/test/ValuedEventsTest.java

@@ -43,10 +43,10 @@ public class ValuedEventsTest extends AbstractExecutionFlowTest {
 		raiseEvent("realEvent", 20l);
 		raiseEvent("stringEvent", "tool");
 		interpreter.runCycle();
-		assertTrue(isActive("D"));
-		assertTrue(isActive("D"));
-		assertTrue(isActive("D"));
-		assertTrue(isActive("D"));
+		assertTrue(isStateActive("D"));
+		assertTrue(isStateActive("D"));
+		assertTrue(isStateActive("D"));
+		assertTrue(isStateActive("D"));
 		assertTrue(getInteger("myInt") == 23l);
 		assertTrue(getBoolean("myBool") == false);
 		assertTrue(getReal("myReal") == 20l);