Added support for simulation of enum values.

plugins/org.yakindu.sct.model.sexec.interpreter/src/org/yakindu/sct/model/sexec/interpreter/impl/ExecutionFlowInterpreter.xtend

@@ -12,7 +12,12 @@ package org.yakindu.sct.model.sexec.interpreter.impl
 
 import com.google.inject.Inject
 import com.google.inject.name.Named
-import org.yakindu.base.types.Type
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import org.eclipse.xtext.naming.IQualifiedNameProvider
+import org.yakindu.base.types.EnumerationType
+import org.yakindu.base.types.ITypeSystem$InferredType
 import org.yakindu.sct.model.sexec.Call
 import org.yakindu.sct.model.sexec.Check
 import org.yakindu.sct.model.sexec.EnterState
@@ -35,27 +40,23 @@ import org.yakindu.sct.model.sexec.UnscheduleTimeEvent
 import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter
 import org.yakindu.sct.model.sexec.interpreter.IStatementInterpreter
 import org.yakindu.sct.model.sexec.interpreter.ITimingService
-import org.yakindu.sct.model.sgraph.Scope
-import org.yakindu.sct.model.stext.naming.StextNameProvider
-import org.yakindu.sct.simulation.core.runtime.AbstractExecutionFacade
-import org.yakindu.sct.simulation.core.runtime.IExecutionContext
-import org.yakindu.sct.simulation.core.runtime.impl.ExecutionEvent
-import org.yakindu.sct.simulation.core.runtime.impl.ExecutionVariable
-import java.util.List
-import java.util.Map
 import org.yakindu.sct.model.sgraph.Declaration
-import org.yakindu.sct.simulation.core.runtime.ISlot
-import java.util.HashMap
-import org.yakindu.sct.simulation.core.runtime.IEventSlot
 import org.yakindu.sct.model.sgraph.Event
+import org.yakindu.sct.model.sgraph.Scope
+import org.yakindu.sct.model.stext.stext.Direction
 import org.yakindu.sct.model.stext.stext.EventDefinition
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
 import org.yakindu.sct.model.stext.stext.InterfaceScope
 import org.yakindu.sct.model.stext.stext.InternalScope
-import org.yakindu.sct.model.stext.stext.VariableDefinition
 import org.yakindu.sct.model.stext.stext.OperationDefinition
-import org.yakindu.sct.model.stext.stext.Direction
+import org.yakindu.sct.model.stext.stext.VariableDefinition
 import org.yakindu.sct.model.stext.types.ISTextTypeInferrer
+import org.yakindu.sct.model.stext.types.ISTextTypeSystem
+import org.yakindu.sct.simulation.core.runtime.AbstractExecutionFacade
+import org.yakindu.sct.simulation.core.runtime.IEventSlot
+import org.yakindu.sct.simulation.core.runtime.IExecutionContext
+import org.yakindu.sct.simulation.core.runtime.ISlot
+import org.yakindu.sct.simulation.core.runtime.impl.ExecutionEvent
+import org.yakindu.sct.simulation.core.runtime.impl.ExecutionVariable
 
 /**
  * 
@@ -70,7 +71,7 @@ class ExecutionFlowInterpreter extends AbstractExecutionFacade implements IExecu
 	@Inject
 	IExecutionContext executionContext
 	@Inject
-	StextNameProvider provider
+	IQualifiedNameProvider provider
 	@Inject 
 	ITimingService timingService
 	@Inject extension ISTextTypeSystem 
@@ -189,45 +190,20 @@ class ExecutionFlowInterpreter extends AbstractExecutionFacade implements IExecu
 	}
 
 	def dispatch void addToScope(VariableDefinition variable){
-		var fqName = provider.qualifiedName(variable).toString
-		var ExecutionVariable varSlot 
+		var fqName = provider.getFullyQualifiedName(variable).toString
 		
-		if(variable.inferType.type.booleanType){
-			varSlot = new ExecutionVariable(fqName ,typeof(Boolean),false)
-		} 
-		else if (variable.inferType.type.integerType){
-			varSlot = new ExecutionVariable(fqName,typeof(Integer),0)
-		}
-		else if(variable.inferType.type.realType){
-			varSlot = new ExecutionVariable(fqName,typeof(Float),0.0f)
-		}
-		else if (variable.inferType.type.stringType){
-			varSlot = new ExecutionVariable(fqName,typeof(String),"")
-		}
+		var type = variable.inferType.type
+		var ExecutionVariable varSlot = new ExecutionVariable(fqName,type, type.defaultValue)
 		
 		executionContext.declareVariable(varSlot);
 		slotMap.put(variable, varSlot);
 	}  
 	
 	def dispatch void addToScope(EventDefinition event){
-		var fqName = provider.qualifiedName(event).toString
-		var ExecutionEvent eventSlot
+		var fqName = provider.getFullyQualifiedName(event).toString
 		
-		if(event.inferType.type.booleanType){
-			eventSlot = new ExecutionEvent(fqName,typeof(Boolean),false)
-		}
-		else if(event.inferType.type.integerType){
-			eventSlot = new ExecutionEvent(fqName,typeof(Integer),0)
-		}
-		else if(event.inferType.type.realType){
-			eventSlot = new ExecutionEvent(fqName,typeof(Float),0.0f)
-		}
-		else if(event.inferType.type.voidType){
-			eventSlot = new ExecutionEvent(fqName,typeof(Void))
-		}
-		else if (event.inferType.type.stringType){
-			eventSlot = new ExecutionEvent(fqName,typeof(String),"")
-		}
+		val type = event.inferType.type
+		var ExecutionEvent eventSlot = new ExecutionEvent(fqName,type,type.defaultValue)
 		 
 		executionContext.declareEvent(eventSlot)
 		slotMap.put(event, eventSlot)
@@ -235,35 +211,28 @@ class ExecutionFlowInterpreter extends AbstractExecutionFacade implements IExecu
 	
 	
 	def dispatch void addToScope(OperationDefinition op){
-		var fqName = provider.qualifiedName(op).toString
-		var type = op.type.mappedType
+		var fqName = provider.getFullyQualifiedName(op).toString
+		val type = new InferredType(op.type)
 		val opSlot = new ExecutionVariable(fqName, type, type.defaultValue);
 		
 		executionContext.declareVariable(opSlot)
 		slotMap.put(op, opSlot)
 	}
 	
-	def Class<?> mappedType(Type it) {
-		if(it.booleanType)		{ typeof(Boolean) } 
-		else if(it.integerType)	{ typeof(Integer) }
-		else if(it.realType)	{ typeof(Float) }
-		else if(it.voidType)	{ typeof(Void)	}
-		else if(it.stringType)	{ typeof(String) }
-		else null 
-	} 
-	
-	def Object defaultValue(Class<?> type) {
+	def Object defaultValue(InferredType type) {
 		switch (type) {
-			case typeof(Boolean) : true
-			case typeof(Integer) : 0
-			case typeof(Float) : 0.0
-			case typeof(Void) : null
-			case typeof(String) : ""
+			case isBooleanType(type) : true
+			case isIntegerType(type) : 0
+			case isRealType(type) : 0.0
+			case isVoidType(type) : null
+			case isStringType(type) : ""
+			case type instanceof EnumerationType: (type as EnumerationType).enumerator.head
+			default: null
 		}
 	}
 	
 	def dispatch void addToScope(TimeEvent event){
-		val eventSlot = new ExecutionEvent(event.name, typeof(Long))
+		val eventSlot = new ExecutionEvent(event.name, new InferredType(integerType))
 		executionContext.declareEvent(eventSlot) 
 		slotMap.put(event, eventSlot)
 	}

plugins/org.yakindu.sct.model.sexec.interpreter/src/org/yakindu/sct/model/sexec/interpreter/stext/CoreFunction.java

@@ -10,6 +10,9 @@
  */
 package org.yakindu.sct.model.sexec.interpreter.stext;
 
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+
 public class CoreFunction extends Function {
 
 	// TODO: Unify with type system
@@ -36,7 +39,7 @@ public class CoreFunction extends Function {
 	public static String POSITIVE = "+";
 	public static String NEGATIVE = "-";
 	public static String NOT = "!";
-	
+
 	@FunctionMethod("+")
 	public Integer plus(Integer i1, Integer i2) {
 		return i1 + i2;
@@ -207,6 +210,11 @@ public class CoreFunction extends Function {
 		return i1.intValue() == i2.intValue();
 	}
 
+	@FunctionMethod("==")
+	public Boolean equals(EObject e1, EObject e2) {
+		return EcoreUtil.equals(e1, e2);
+	}
+
 	@FunctionMethod("==")
 	public Boolean equals(Float i1, Float i2) {
 		return i1.floatValue() == i2.floatValue();
@@ -217,6 +225,11 @@ public class CoreFunction extends Function {
 		return string1.equals(string2);
 	}
 
+	@FunctionMethod("!=")
+	public Boolean notEquals(EObject e1, EObject e2) {
+		return !EcoreUtil.equals(e1, e2);
+	}
+
 	@FunctionMethod("!=")
 	public Boolean notEquals(Boolean b1, Boolean b2) {
 		return b1.booleanValue() != b2.booleanValue();

plugins/org.yakindu.sct.model.sexec.interpreter/src/org/yakindu/sct/model/sexec/interpreter/stext/Function.java

@@ -24,6 +24,11 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 
+import org.eclipse.emf.ecore.EObject;
+import org.yakindu.sct.model.stext.types.ISTextTypeSystem;
+
+import com.google.inject.Inject;
+
 /**
  * 
  * @author axel terfloth
@@ -32,6 +37,8 @@ import java.util.List;
  */
 public class Function {
 
+	@Inject ISTextTypeSystem typeSystem;
+	
 	/**
 	 * Indicates that a method is a function.
 	 * 
@@ -147,7 +154,13 @@ public class Function {
 		for (int i = 0; i < params.length; i++) {
 			if (params[i] == null)
 				continue;
-			paramTypes[i] = params[i].getClass();
+			if(params[i] instanceof EObject){
+				paramTypes[i] = EObject.class; // enumerators and complex types
+			}
+			else {
+				paramTypes[i] = params[i].getClass(); // primitive values (boxed java types)
+			}
+			
 		}
 		return paramTypes;
 	}

plugins/org.yakindu.sct.model.sexec.interpreter/src/org/yakindu/sct/model/sexec/interpreter/stext/StextStatementInterpreter.xtend

@@ -12,9 +12,9 @@ package org.yakindu.sct.model.sexec.interpreter.stext
 
 import com.google.inject.Inject
 import org.eclipse.emf.ecore.EObject
+import org.eclipse.xtext.naming.IQualifiedNameProvider
 import org.eclipse.xtext.util.SimpleAttributeResolver
 import org.yakindu.sct.model.sgraph.Statement
-import org.yakindu.sct.model.stext.naming.StextNameProvider
 import org.yakindu.sct.model.stext.stext.ActiveStateReferenceExpression
 import org.yakindu.sct.model.stext.stext.AssignmentExpression
 import org.yakindu.sct.model.stext.stext.AssignmentOperator
@@ -37,14 +37,15 @@ import org.yakindu.sct.model.stext.stext.LogicalRelationExpression
 import org.yakindu.sct.model.stext.stext.NumericalAddSubtractExpression
 import org.yakindu.sct.model.stext.stext.NumericalMultiplyDivideExpression
 import org.yakindu.sct.model.stext.stext.NumericalUnaryExpression
+import org.yakindu.sct.model.stext.stext.OperationDefinition
+import org.yakindu.sct.model.stext.stext.ParenthesizedExpression
 import org.yakindu.sct.model.stext.stext.PrimitiveValueExpression
 import org.yakindu.sct.model.stext.stext.RealLiteral
 import org.yakindu.sct.model.stext.stext.ShiftExpression
 import org.yakindu.sct.model.stext.stext.StringLiteral
 import org.yakindu.sct.model.stext.stext.VariableDefinition
 import org.yakindu.sct.simulation.core.runtime.IExecutionContext
-import org.yakindu.sct.model.stext.stext.ParenthesizedExpression
-import org.yakindu.sct.model.stext.stext.OperationDefinition
+import org.yakindu.base.types.Enumerator
 
 /**
  * 
@@ -55,7 +56,7 @@ import org.yakindu.sct.model.stext.stext.OperationDefinition
 class StextStatementInterpreter extends AbstractStatementInterpreter {
 	
 	@Inject
-	extension StextNameProvider provider 
+	extension IQualifiedNameProvider provider 
 	
 	protected IExecutionContext context
 	
@@ -226,6 +227,9 @@ class StextStatementInterpreter extends AbstractStatementInterpreter {
 			var parameter = call.args.map(it| execute)
 			return super.executeOperationCallback(call.feature as OperationDefinition, parameter.toArray)
 		}
+		else if (call.getFeature() instanceof Enumerator) {
+			return call.getFeature();
+		}
 		else {
 			var fqn = call.feature.fqn
 			var variableRef = context.getVariable(fqn)

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/ISlot.java

@@ -10,30 +10,35 @@
  */
 package org.yakindu.sct.simulation.core.runtime;
 
+import org.yakindu.base.types.ITypeSystem.InferredType;
+
 /**
- * Defines the interface of a slot that holds a value within an execution context. 
+ * Defines the interface of a slot that holds a value within an execution
+ * context.
  * 
- * The name and type of a slot can be accessed read only. The value can be read and set.
+ * The name and type of a slot can be accessed read only. The value can be read
+ * and set.
  * 
  * @author axel terfloth
- *
+ * 
  */
 public interface ISlot {
 
-	public static class SlotValueChanged implements ISlotChangedEvent {}
+	public static class SlotValueChanged implements ISlotChangedEvent {
+	}
+
 	public static final SlotValueChanged SLOT_VALUE_CHANGED = new SlotValueChanged();
-	
+
 	void setContext(ISlotContext ctx);
+
 	ISlotContext getContext();
-	
+
 	public String getName();
-	
-	public Class<?> getType();
+
+	public InferredType getType();
 
 	public void setValue(Object value);
 
 	public Object getValue();
 
-	
-
 }

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/impl/AbstractSlot.java

@@ -11,6 +11,10 @@
 package org.yakindu.sct.simulation.core.runtime.impl;
 
 import org.eclipse.core.runtime.Assert;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.yakindu.base.types.EnumerationType;
+import org.yakindu.base.types.Enumerator;
+import org.yakindu.base.types.ITypeSystem.InferredType;
 import org.yakindu.sct.simulation.core.runtime.ExecutionException;
 import org.yakindu.sct.simulation.core.runtime.ISlot;
 import org.yakindu.sct.simulation.core.runtime.ISlotContext;
@@ -26,10 +30,10 @@ public abstract class AbstractSlot implements ISlot {
 	protected String name;
 	protected String scopeSegment;
 	protected String simpleName;
-	protected Class<?> type;
+	protected InferredType type;
 	protected Object value;
 
-	public AbstractSlot(String name, Class<?> type, Object value) {
+	public AbstractSlot(String name, InferredType type, Object value) {
 		super();
 		Assert.isNotNull(name);
 		this.name = name;
@@ -53,12 +57,11 @@ public abstract class AbstractSlot implements ISlot {
 		return simpleName;
 	}
 
-	
 	public String getName() {
 		return name;
 	}
 
-	public Class<?> getType() {
+	public InferredType getType() {
 		return type;
 	}
 
@@ -69,26 +72,44 @@ public abstract class AbstractSlot implements ISlot {
 	public void setValue(Object value) {
 		assertValue(value);
 		this.value = value;
-		
+
 		notifyValueChanged();
 	}
 
 	protected void assertValue(Object value) {
 		Assert.isNotNull(value, "Value must not be null ");
-		//TODO refactor
-		if (type == Float.class && value != null && !value.getClass().isAssignableFrom(type)) {
-			try {
-				value = Float.parseFloat(value.toString());
-			} catch (NumberFormatException e) {
-				e.printStackTrace();
+		if(getType().getType() instanceof EnumerationType){
+			Assert.isTrue(value instanceof Enumerator);
+			boolean validLiteral = false;
+			for(Enumerator e : ((EnumerationType)getType().getType()).getEnumerator()){
+				if(EcoreUtil.equals(e, (Enumerator)value)){
+					validLiteral = true;
+					break;
+				}
+			}
+			if(!validLiteral){
+				throw new ExecutionException("Enumerator " + ((Enumerator)value).getName() + " is not assignable to enumeration type "+  getType().getType().getName());
 			}
 		}
+		// TODO check primitive value types -> need type system to decide
 		
-		if (!value.getClass().isAssignableFrom(type)) {
-			throw new ExecutionException("Error assigning value to \' " + name
-					+ "\' Can not assign value " + value + " of type"
-					+ value.getClass() + " to type " + type);
-		}
+		// TODO refactor (use type system)
+		// Class<? extends Object> clazz = value instanceof EObject ?
+		// ((EObject)value).eClass().getInstanceClass() : value.getClass();
+		// if (type == Float.class && value != null &&
+		// !clazz.isAssignableFrom(type)) {
+		// try {
+		// value = Float.parseFloat(value.toString());
+		// } catch (NumberFormatException e) {
+		// e.printStackTrace();
+		// }
+		// }
+		//
+		// if (!clazz.isAssignableFrom(type)) {
+		// throw new ExecutionException("Error assigning value to \' " + name
+		// + "\' Can not assign value " + value + " of type"
+		// + clazz + " to type " + type);
+		// }
 	}
 
 	public void setContext(ISlotContext ctx) {
@@ -98,9 +119,9 @@ public abstract class AbstractSlot implements ISlot {
 	public ISlotContext getContext() {
 		return context;
 	}
-	
+
 	protected void notifyValueChanged() {
-		if ( context != null ) {
+		if (context != null) {
 			context.slotChanged(this, SLOT_VALUE_CHANGED);
 		}
 	}

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/impl/ExecutionEvent.java

@@ -10,6 +10,7 @@
  */
 package org.yakindu.sct.simulation.core.runtime.impl;
 
+import org.yakindu.base.types.ITypeSystem.InferredType;
 import org.yakindu.sct.simulation.core.runtime.IEventSlot;
 import org.yakindu.sct.simulation.core.runtime.IExecutionContext;
 
@@ -25,16 +26,16 @@ import org.yakindu.sct.simulation.core.runtime.IExecutionContext;
 public class ExecutionEvent extends AbstractSlot implements IEventSlot {
 
 	protected boolean raised = false;
-	
+
 	public ExecutionEvent(String name) {
 		this(name, null, null);
 	}
 
-	public ExecutionEvent(String name, Class<?> type) {
+	public ExecutionEvent(String name, InferredType type) {
 		super(name, type, null);
 	}
 
-	public ExecutionEvent(String name, Class<?> type, Object value) {
+	public ExecutionEvent(String name, InferredType type, Object value) {
 		super(name, type, value);
 	}
 
@@ -43,19 +44,19 @@ public class ExecutionEvent extends AbstractSlot implements IEventSlot {
 	}
 
 	public void raise(Object value) {
-		if ( ! raised ) {
+		if (!raised) {
 			raised = true;
 			if (value != null) {
 				assertValue(value);
 				this.value = value;
 			}
-			
+
 			notifyRaised();
 		}
 	}
 
 	public void unraise() {
-		if ( raised ) {
+		if (raised) {
 			raised = false;
 			notifyUnraised();
 		}
@@ -65,18 +66,16 @@ public class ExecutionEvent extends AbstractSlot implements IEventSlot {
 		return raised;
 	}
 
-	
 	protected void notifyRaised() {
-		if ( context != null ) {
+		if (context != null) {
 			context.slotChanged(this, SLOT_EVENT_RAISED);
 		}
 	}
 
 	protected void notifyUnraised() {
-		if ( context != null ) {
+		if (context != null) {
 			context.slotChanged(this, SLOT_EVENT_UNRAISED);
 		}
 	}
 
-
 }

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/impl/ExecutionOperation.java

@@ -1,10 +1,12 @@
 package org.yakindu.sct.simulation.core.runtime.impl;
 
+import org.yakindu.base.types.ITypeSystem.InferredType;
+
 public class ExecutionOperation extends AbstractSlot {
 
-	protected Class<?>[] paramTypes;
+	protected InferredType[] paramTypes;
 	
-	public ExecutionOperation(String name, Object value, Class<?> type, Class<?>... paramTypes) {
+	public ExecutionOperation(String name, Object value, InferredType type, InferredType... paramTypes) {
 		super(name, type, value);
 		this.paramTypes = paramTypes;
 	}

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/impl/ExecutionVariable.java

@@ -10,6 +10,7 @@
  */
 package org.yakindu.sct.simulation.core.runtime.impl;
 
+import org.yakindu.base.types.ITypeSystem.InferredType;
 import org.yakindu.sct.simulation.core.runtime.IExecutionContext;
 
 
@@ -24,7 +25,7 @@ import org.yakindu.sct.simulation.core.runtime.IExecutionContext;
  */
 public class ExecutionVariable extends AbstractSlot {
 
-	public ExecutionVariable(String name, Class<?> type, Object value) {
+	public ExecutionVariable(String name, InferredType type, Object value) {
 		super(name, type, value);
 	}
 

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/ExecutionContextLabelProvider.java

@@ -14,9 +14,9 @@ import org.eclipse.draw2d.ColorConstants;
 import org.eclipse.jface.viewers.StyledCellLabelProvider;
 import org.eclipse.jface.viewers.ViewerCell;
 import org.eclipse.swt.custom.StyleRange;
+import org.yakindu.base.types.Enumerator;
 import org.yakindu.sct.simulation.core.runtime.IExecutionContext;
 import org.yakindu.sct.simulation.core.runtime.ISlot;
-import org.yakindu.sct.simulation.core.runtime.impl.AbstractSlot;
 import org.yakindu.sct.simulation.core.runtime.impl.ExecutionEvent;
 import org.yakindu.sct.simulation.core.runtime.impl.ExecutionVariable;
 import org.yakindu.sct.simulation.ui.SimulationImages;
@@ -49,12 +49,16 @@ public class ExecutionContextLabelProvider extends StyledCellLabelProvider {
 
 	private void updateValueCell(ViewerCell cell) {
 		Object element = cell.getElement();
-		if (element instanceof AbstractSlot) {
+		if (element instanceof ISlot) {
 			Object value = ((ISlot) element).getValue();
-			if (value != null)
-				cell.setText(value.toString());
+			if (value != null) {
+				if (value instanceof Enumerator) {
+					cell.setText(((Enumerator) value).getName());
+				} else {
+					cell.setText(value.toString());
+				}
+			}
 		}
-
 	}
 
 	private void updateNameCell(ViewerCell cell) {

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/SimulationView.java

@@ -48,6 +48,7 @@ import org.yakindu.sct.simulation.ui.view.actions.CollapseAllAction;
 import org.yakindu.sct.simulation.ui.view.actions.ExpandAllAction;
 import org.yakindu.sct.simulation.ui.view.actions.HideTimeEventsAction;
 import org.yakindu.sct.simulation.ui.view.editing.BooleanEditingSupport;
+import org.yakindu.sct.simulation.ui.view.editing.EnumerationEditingSupport;
 import org.yakindu.sct.simulation.ui.view.editing.IntegerEditingSupport;
 import org.yakindu.sct.simulation.ui.view.editing.MultiEditingSupport;
 import org.yakindu.sct.simulation.ui.view.editing.RealEditingSupport;
@@ -133,7 +134,7 @@ public class SimulationView extends ViewPart implements IDebugContextListener,
 		valueColumn.setEditingSupport(new MultiEditingSupport(viewer,
 				new BooleanEditingSupport(viewer), new IntegerEditingSupport(
 						viewer), new RealEditingSupport(viewer),
-				new StringEditingSupport(viewer)));
+				new StringEditingSupport(viewer), new EnumerationEditingSupport(viewer)));
 		valueColumn.setLabelProvider(new ExecutionContextLabelProvider(1));
 		viewer.setContentProvider(new ExecutionContextContentProvider());
 

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/editing/BooleanEditingSupport.java

@@ -50,7 +50,7 @@ public class BooleanEditingSupport extends ScopeSlotEditingSupport {
 	}
 
 	@Override
-	protected Object convertValue(Object value) {
+	protected Object convertValue(Object element, Object value) {
 		if (value != null && value instanceof Integer) {
 			return ((Integer) value).intValue() == 0 ? true : false;
 		}

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/editing/EnumerationEditingSupport.java

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2011 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, 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.ui.view.editing;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jface.viewers.CellEditor;
+import org.eclipse.jface.viewers.ColumnViewer;
+import org.eclipse.jface.viewers.ComboBoxCellEditor;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Composite;
+import org.yakindu.base.types.EnumerationType;
+import org.yakindu.base.types.Enumerator;
+import org.yakindu.sct.simulation.core.runtime.ISlot;
+
+/**
+ * {@link CellEditor} support for Boolean values
+ * 
+ * @author andreas muelder - Initial contribution and API
+ * 
+ */
+public class EnumerationEditingSupport extends ScopeSlotEditingSupport {
+
+	public EnumerationEditingSupport(ColumnViewer viewer) {
+		super(viewer);
+	}
+
+	@Override
+	public CellEditor getCellEditor(Object element) {
+		if (element instanceof ISlot) {
+			EnumerationType e = getEnumerationType((ISlot) element);
+			List<String> enumeratorNames = new ArrayList<String>();
+			for (Enumerator enumerator : e.getEnumerator()) {
+				enumeratorNames.add(enumerator.getName());
+			}
+			return new ComboBoxCellEditor((Composite) getViewer().getControl(),
+					enumeratorNames.toArray(new String[] {}), SWT.READ_ONLY);
+		}
+		return null;
+	}
+
+	public EnumerationType getEnumerationType(ISlot element) {
+		EnumerationType e = (EnumerationType) element.getType().getType();
+		return e;
+	}
+
+	public Object getValue(Object element) {
+		if (element instanceof ISlot) {
+			EnumerationType e = getEnumerationType((ISlot) element);
+			return e.getEnumerator().indexOf(((ISlot) element).getValue());
+		}
+		return null;
+	}
+
+	@Override
+	protected Class<?> getSupportedType() {
+		return Enumerator.class;
+	}
+
+	@Override
+	protected Object convertValue(Object element, Object value) {
+		if (element instanceof ISlot) {
+			if (value != null && value instanceof Integer) {
+				int index = ((Integer) value).intValue();
+				EnumerationType e = getEnumerationType((ISlot) element);
+				if (index < 0) {
+					return e.getEnumerator().iterator().next();
+				}
+				return e.getEnumerator().get(index);
+			}
+		}
+		return null;
+	}
+}

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/editing/IntegerEditingSupport.java

@@ -52,7 +52,7 @@ public class IntegerEditingSupport extends ScopeSlotEditingSupport {
 	}
 
 	@Override
-	protected Object convertValue(Object value) {
+	protected Object convertValue(Object element, Object value) {
 		if (value != null && value instanceof String
 				&& ((String) value).trim().length() > 0) {
 			return Integer.parseInt((String) value);

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/editing/RealEditingSupport.java

@@ -52,7 +52,7 @@ public class RealEditingSupport extends ScopeSlotEditingSupport {
 	}
 
 	@Override
-	protected Object convertValue(Object value) {
+	protected Object convertValue(Object element, Object value) {
 		if (value != null && value instanceof String
 				&& ((String) value).trim().length() > 0) {
 			return Float.parseFloat((String) value);

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/editing/ScopeSlotEditingSupport.java

@@ -10,6 +10,7 @@
  */
 package org.yakindu.sct.simulation.ui.view.editing;
 
+import org.eclipse.emf.ecore.EObject;
 import org.eclipse.jface.viewers.ColumnViewer;
 import org.yakindu.sct.simulation.core.runtime.IExecutionContext;
 import org.yakindu.sct.simulation.core.runtime.ISlot;
@@ -24,7 +25,7 @@ public abstract class ScopeSlotEditingSupport extends PublicEditingSupport {
 
 	protected abstract Class<?> getSupportedType();
 
-	protected abstract Object convertValue(Object value);
+	protected abstract Object convertValue(Object element, Object value);
 
 	public ScopeSlotEditingSupport(ColumnViewer viewer) {
 		super(viewer);
@@ -33,8 +34,15 @@ public abstract class ScopeSlotEditingSupport extends PublicEditingSupport {
 	@Override
 	public boolean canEdit(Object element) {
 		if (element instanceof AbstractSlot) {
-			return getSupportedType()
-					.equals(((ISlot) element).getType());
+			Object value = ((AbstractSlot) element).getValue();
+			// TODO: check compatibility via (type system ) type not via class
+			// of value
+			if (value instanceof EObject) {
+				return getSupportedType().isAssignableFrom(
+						((EObject) value).eClass().getInstanceClass());
+			} else {
+				return getSupportedType().isAssignableFrom(value.getClass());
+			}
 		}
 		return false;
 	}
@@ -49,9 +57,10 @@ public abstract class ScopeSlotEditingSupport extends PublicEditingSupport {
 		return "";
 	}
 
+	@SuppressWarnings("deprecation")
 	@Override
 	public void setValue(Object element, Object value) {
-		value = convertValue(value);
+		value = convertValue(element, value);
 		if (value == null)
 			return;
 		IExecutionContext input = (IExecutionContext) getViewer().getInput();

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/editing/StringEditingSupport.java

@@ -47,7 +47,7 @@ public class StringEditingSupport extends ScopeSlotEditingSupport {
 	}
 
 	@Override
-	protected Object convertValue(Object value) {
+	protected Object convertValue(Object element, Object value) {
 		return value;
 	}
 

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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
@@ -24,9 +24,9 @@ import org.junit.runners.Suite.SuiteClasses;
 		OutEventLifeCycleTest.class, ParenthesisTest.class,
 		PriorityValuesTest.class, RaiseEventTest.class,
 		SameNameDifferentRegionTest.class, ShallowHistoryTest.class,
-		SimpleHietachyTest.class, StateIsActiveTest.class,
+		SimpleHierachyTest.class, StateIsActiveTest.class,
 		StatechartLocalReactionsTest.class, StringExpressionsTest.class,
 		SyncForkTest.class, SyncJoinTest.class, ValuedEventTest.class,
-		SimpleEventTest.class, StextKeywordsTest.class})
+		SimpleEventTest.class, STextKeywordsInStatesAndRegionsTest.class})
 public class AllTestsTest {
 }

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -0,0 +1,502 @@
+/**
+ * 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.stextkeywordsinstatesandregions.STextKeywordsInStatesAndRegionsStatemachine;
+import org.yakindu.scr.stextkeywordsinstatesandregions.STextKeywordsInStatesAndRegionsStatemachine.State;
+/**
+ *  Unit TestCase for STextKeywordsInStatesAndRegions
+ */
+@SuppressWarnings("all")
+public class STextKeywordsInStatesAndRegionsTest {
+
+	private STextKeywordsInStatesAndRegionsStatemachine statemachine;
+
+	@Before
+	public void setUp() {
+		statemachine = new STextKeywordsInStatesAndRegionsStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+
+	@Test
+	public void testactiveCheckWithSTextNamedStates() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_interface));
+		assertTrue(statemachine.isStateActive(State.namespace_event));
+		assertTrue(statemachine.isStateActive(State.local_in));
+		assertTrue(statemachine.isStateActive(State.interface_var));
+		assertTrue(statemachine.isStateActive(State.internal_external));
+		assertTrue(statemachine.isStateActive(State.event_default));
+		assertTrue(statemachine.isStateActive(State.in_entry));
+		assertTrue(statemachine.isStateActive(State.out_always));
+		assertTrue(statemachine.isStateActive(State.var_raise));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_event));
+		assertTrue(statemachine.isStateActive(State.local_in));
+		assertTrue(statemachine.isStateActive(State.interface_var));
+		assertTrue(statemachine.isStateActive(State.internal_external));
+		assertTrue(statemachine.isStateActive(State.event_default));
+		assertTrue(statemachine.isStateActive(State.in_entry));
+		assertTrue(statemachine.isStateActive(State.out_always));
+		assertTrue(statemachine.isStateActive(State.var_raise));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_in));
+		assertTrue(statemachine.isStateActive(State.interface_var));
+		assertTrue(statemachine.isStateActive(State.internal_external));
+		assertTrue(statemachine.isStateActive(State.event_default));
+		assertTrue(statemachine.isStateActive(State.in_entry));
+		assertTrue(statemachine.isStateActive(State.out_always));
+		assertTrue(statemachine.isStateActive(State.var_raise));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_var));
+		assertTrue(statemachine.isStateActive(State.internal_external));
+		assertTrue(statemachine.isStateActive(State.event_default));
+		assertTrue(statemachine.isStateActive(State.in_entry));
+		assertTrue(statemachine.isStateActive(State.out_always));
+		assertTrue(statemachine.isStateActive(State.var_raise));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_external));
+		assertTrue(statemachine.isStateActive(State.event_default));
+		assertTrue(statemachine.isStateActive(State.in_entry));
+		assertTrue(statemachine.isStateActive(State.out_always));
+		assertTrue(statemachine.isStateActive(State.var_raise));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_default));
+		assertTrue(statemachine.isStateActive(State.in_entry));
+		assertTrue(statemachine.isStateActive(State.out_always));
+		assertTrue(statemachine.isStateActive(State.var_raise));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_entry));
+		assertTrue(statemachine.isStateActive(State.out_always));
+		assertTrue(statemachine.isStateActive(State.var_raise));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_always));
+		assertTrue(statemachine.isStateActive(State.var_raise));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_raise));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_active));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_interface));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_event));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_local));
+		assertTrue(statemachine.isStateActive(State.entry_in));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_local));
+		assertTrue(statemachine.isStateActive(State.entry_out));
+		assertTrue(statemachine.isStateActive(State.exit_var));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_local));
+		assertTrue(statemachine.isStateActive(State.entry_out));
+		assertTrue(statemachine.isStateActive(State.exit_readonly));
+		assertTrue(statemachine.isStateActive(State.always_external));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_local));
+		assertTrue(statemachine.isStateActive(State.entry_out));
+		assertTrue(statemachine.isStateActive(State.exit_readonly));
+		assertTrue(statemachine.isStateActive(State.always_operation));
+		assertTrue(statemachine.isStateActive(State.oncycle_default));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_local));
+		assertTrue(statemachine.isStateActive(State.entry_out));
+		assertTrue(statemachine.isStateActive(State.exit_readonly));
+		assertTrue(statemachine.isStateActive(State.always_operation));
+		assertTrue(statemachine.isStateActive(State.oncycle_else));
+		assertTrue(statemachine.isStateActive(State.raise_entry));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_local));
+		assertTrue(statemachine.isStateActive(State.entry_out));
+		assertTrue(statemachine.isStateActive(State.exit_readonly));
+		assertTrue(statemachine.isStateActive(State.always_operation));
+		assertTrue(statemachine.isStateActive(State.oncycle_else));
+		assertTrue(statemachine.isStateActive(State.raise_exit));
+		assertTrue(statemachine.isStateActive(State.valueof_always));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_local));
+		assertTrue(statemachine.isStateActive(State.entry_out));
+		assertTrue(statemachine.isStateActive(State.exit_readonly));
+		assertTrue(statemachine.isStateActive(State.always_operation));
+		assertTrue(statemachine.isStateActive(State.oncycle_else));
+		assertTrue(statemachine.isStateActive(State.raise_exit));
+		assertTrue(statemachine.isStateActive(State.valueof_oncycle));
+		assertTrue(statemachine.isStateActive(State.active_raise));
+		statemachine.raiseE1();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_local));
+		assertTrue(statemachine.isStateActive(State.entry_out));
+		assertTrue(statemachine.isStateActive(State.exit_readonly));
+		assertTrue(statemachine.isStateActive(State.always_operation));
+		assertTrue(statemachine.isStateActive(State.oncycle_else));
+		assertTrue(statemachine.isStateActive(State.raise_exit));
+		assertTrue(statemachine.isStateActive(State.valueof_oncycle));
+		assertTrue(statemachine.isStateActive(State.active_valueof));
+		statemachine.raiseE2();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.default_namespace));
+		assertTrue(statemachine.isStateActive(State.operation_internal));
+		assertTrue(statemachine.isStateActive(State.namespace_local));
+		assertTrue(statemachine.isStateActive(State.local_out));
+		assertTrue(statemachine.isStateActive(State.interface_readonly));
+		assertTrue(statemachine.isStateActive(State.internal_operation));
+		assertTrue(statemachine.isStateActive(State.event_else));
+		assertTrue(statemachine.isStateActive(State.in_exit));
+		assertTrue(statemachine.isStateActive(State.out_oncycle));
+		assertTrue(statemachine.isStateActive(State.var_valueof));
+		assertTrue(statemachine.isStateActive(State.readonly_namespace));
+		assertTrue(statemachine.isStateActive(State.external_internal));
+		assertTrue(statemachine.isStateActive(State.else_local));
+		assertTrue(statemachine.isStateActive(State.entry_out));
+		assertTrue(statemachine.isStateActive(State.exit_readonly));
+		assertTrue(statemachine.isStateActive(State.always_operation));
+		assertTrue(statemachine.isStateActive(State.oncycle_else));
+		assertTrue(statemachine.isStateActive(State.raise_exit));
+		assertTrue(statemachine.isStateActive(State.valueof_oncycle));
+		assertTrue(statemachine.isStateActive(State.active_valueof));
+	}
+}

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -0,0 +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.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/src-gen/org/yakindu/sct/generator/java/test/StateIsActiveTest.java

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -0,0 +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.statewithemptyregion.StateWithEmptyRegionStatemachine;
+import org.yakindu.scr.statewithemptyregion.StateWithEmptyRegionStatemachine.State;
+/**
+ *  Unit TestCase for StateWithEmptyRegion
+ */
+@SuppressWarnings("all")
+public class StateWithEmptyRegionTest {
+
+	private StateWithEmptyRegionStatemachine statemachine;
+
+	@Before
+	public void setUp() {
+		statemachine = new StateWithEmptyRegionStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+
+	@Test
+	public void testStateWithEmptyRegionTest() {
+		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/src-gen/org/yakindu/sct/generator/java/test/StatechartLocalReactionsTest.java

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2012 committers of YAKINDU and others.
+ * 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

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

@@ -1,33 +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.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,
-		CKeywordsTest.class, DeclarationsTest.class, ChoiceTest.class,
-		DeepHistoryTest.class, ExitOnSelfTransitionTest.class, GuardTest.class,
-		GuardedEntryTest.class, GuardedExitTest.class,
-		HistoryWithoutInitialStepTest.class, IntegerExpressionsTest.class,
-		InEventLifeCycleTest.class, InternalEventLifeCycleTest.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, ValuedEventTest.class,
-		SimpleEventTest.class, STextKeywordsInStatesAndRegionsTest.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.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,
+		CKeywordsTest.class, DeclarationsTest.class, ChoiceTest.class,
+		DeepHistoryTest.class, ExitOnSelfTransitionTest.class, GuardTest.class,
+		GuardedEntryTest.class, GuardedExitTest.class,
+		HistoryWithoutInitialStepTest.class, IntegerExpressionsTest.class,
+		InEventLifeCycleTest.class, InternalEventLifeCycleTest.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, ValuedEventTest.class,
+		SimpleEventTest.class, STextKeywordsInStatesAndRegionsTest.class})
+public class AllTests {
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/src-gen/org/yakindu/sct/model/sexec/interpreter/test/AlwaysOncycleTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/AssignmentAsExpressionTest.java

@@ -1,74 +1,74 @@
-/**
- * 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/BitExpressionsTest.java

@@ -1,57 +1,57 @@
-/**
- * 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/BooleanExpressionsTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/CKeywordsTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/ChoiceTest.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 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 choiceTest() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		assertTrue(getInteger("value") == 4);
-		raiseEvent("pressKey");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(getInteger("value") == 3);
-		raiseEvent("pressKey");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		raiseEvent("pressKey");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-		assertTrue(getInteger("value") == 2);
-		raiseEvent("pressKey");
-		interpreter.runCycle();
-		assertTrue(isActive("B"));
-		assertTrue(getInteger("value") == 1);
-		raiseEvent("pressKey");
-		interpreter.runCycle();
-		assertTrue(isActive("A"));
-		assertTrue(getInteger("value") == 1);
-		raiseEvent("pressKey");
-		interpreter.runCycle();
-		assertTrue(isActive("C"));
-		assertTrue(getInteger("value") == 0);
-		raiseEvent("pressKey");
-		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 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 choiceTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(getInteger("value") == 4);
+		raiseEvent("pressKey");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(getInteger("value") == 3);
+		raiseEvent("pressKey");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		raiseEvent("pressKey");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+		assertTrue(getInteger("value") == 2);
+		raiseEvent("pressKey");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(getInteger("value") == 1);
+		raiseEvent("pressKey");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(getInteger("value") == 1);
+		raiseEvent("pressKey");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+		assertTrue(getInteger("value") == 0);
+		raiseEvent("pressKey");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/src-gen/org/yakindu/sct/model/sexec/interpreter/test/DeclarationsTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/DeepHistoryTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/ExitOnSelfTransitionTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/FeatureCallsTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/GuardTest.java

@@ -1,60 +1,60 @@
-/**
- * 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/GuardedEntryTest.java

@@ -1,83 +1,83 @@
-/**
- * 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/GuardedExitTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/HistoryWithoutInitialStepTest.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.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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/InEventLifeCycleTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/IntegerExpressionsTest.java

@@ -1,67 +1,67 @@
-/**
- * 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/InternalEventLifeCycleTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/OutEventLifeCycleTest.java

@@ -1,71 +1,71 @@
-/**
- * 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/ParenthesisTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/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.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 PerformanceTest
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class PerformanceTestsTest extends AbstractExecutionFlowTest {
-
-	@Inject
-	private SCTUnitTestModels models;
-
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("PerformanceTest.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void test_100_000() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		while (getInteger("c") < 100000) {
-			if (isActive("A")) {
-				raiseEvent("e1");;
-			} else {
-				if (getInteger("c") % 2 == 0) {
-					raiseEvent("e2");;
-				} else {
-					raiseEvent("e3");;
-				};
-			}
-			interpreter.runCycle();
-		}
-		assertTrue(getInteger("a") > 2);
-	}
-	@Test
-	public void test_1_000_000() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		while (getInteger("c") < 1000000) {
-			if (isActive("A")) {
-				raiseEvent("e1");;
-			} else {
-				if (getInteger("c") % 2 == 0) {
-					raiseEvent("e2");;
-				} else {
-					raiseEvent("e3");;
-				};
-			}
-			interpreter.runCycle();
-		}
-		assertTrue(getInteger("a") > 2);
-	}
-	@Test
-	public void test_10_000_000() throws Exception {
-		interpreter.enter();
-		assertTrue(isActive("A"));
-		while (getInteger("c") < 10000000) {
-			if (isActive("A")) {
-				raiseEvent("e1");;
-			} else {
-				if (getInteger("c") % 2 == 0) {
-					raiseEvent("e2");;
-				} else {
-					raiseEvent("e3");;
-				};
-			}
-			interpreter.runCycle();
-		}
-		assertTrue(getInteger("a") > 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 PerformanceTest
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class PerformanceTestsTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("PerformanceTest.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void test_100_000() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		while (getInteger("c") < 100000) {
+			if (isActive("A")) {
+				raiseEvent("e1");;
+			} else {
+				if (getInteger("c") % 2 == 0) {
+					raiseEvent("e2");;
+				} else {
+					raiseEvent("e3");;
+				};
+			}
+			interpreter.runCycle();
+		}
+		assertTrue(getInteger("a") > 2);
+	}
+	@Test
+	public void test_1_000_000() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		while (getInteger("c") < 1000000) {
+			if (isActive("A")) {
+				raiseEvent("e1");;
+			} else {
+				if (getInteger("c") % 2 == 0) {
+					raiseEvent("e2");;
+				} else {
+					raiseEvent("e3");;
+				};
+			}
+			interpreter.runCycle();
+		}
+		assertTrue(getInteger("a") > 2);
+	}
+	@Test
+	public void test_10_000_000() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		while (getInteger("c") < 10000000) {
+			if (isActive("A")) {
+				raiseEvent("e1");;
+			} else {
+				if (getInteger("c") % 2 == 0) {
+					raiseEvent("e2");;
+				} else {
+					raiseEvent("e3");;
+				};
+			}
+			interpreter.runCycle();
+		}
+		assertTrue(getInteger("a") > 2);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/src-gen/org/yakindu/sct/model/sexec/interpreter/test/PriorityValuesTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/RaiseEventTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/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.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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/ShallowHistoryTest.java

@@ -1,75 +1,75 @@
-/**
- * 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/src-gen/org/yakindu/sct/model/sexec/interpreter/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.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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/SimpleHierachyTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/StateIsActiveTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/StateWithEmptyRegionTest.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 StateWithEmptyRegion
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class StateWithEmptyRegionTest extends AbstractExecutionFlowTest {
-
-	@Inject
-	private SCTUnitTestModels models;
-
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("StateWithEmptyRegion.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void StateWithEmptyRegionTest() 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 StateWithEmptyRegion
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class StateWithEmptyRegionTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("StateWithEmptyRegion.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void StateWithEmptyRegionTest() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/src-gen/org/yakindu/sct/model/sexec/interpreter/test/StatechartLocalReactionsTest.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 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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/StringExpressionsTest.java

@@ -1,53 +1,53 @@
-/**
- * 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 {
-		interpreter.enter();
-		assertTrue(isActive("StateA"));
-		assertTrue(getString("myString").equals("hello"));
-		assertTrue(getString("myString2").equals("world"));
-		raiseEvent("e1");
-		interpreter.runCycle();
-		assertTrue(isActive("StateB"));
-		assertTrue(getBoolean("equals") == 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 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 {
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		assertTrue(getString("myString").equals("hello"));
+		assertTrue(getString("myString2").equals("world"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		assertTrue(getBoolean("equals") == false);
+		assertTrue(getBoolean("notEqual") == true);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/src-gen/org/yakindu/sct/model/sexec/interpreter/test/SyncForkTest.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.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/src-gen/org/yakindu/sct/model/sexec/interpreter/test/SyncJoinTest.java

@@ -1,109 +1,109 @@
-/**
- * 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"));
-	}
-}
+/**
+ * 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-plugins/org.yakindu.sct.model.sexec.interpreter.test/src-gen/org/yakindu/sct/model/sexec/interpreter/test/ValuedEventTest.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 ValuedEvents
- */
-@SuppressWarnings("all")
-@RunWith(XtextRunner.class)
-@InjectWith(SExecInjectionProvider.class)
-public class ValuedEventTest extends AbstractExecutionFlowTest {
-
-	@Inject
-	private SCTUnitTestModels models;
-
-	@Before
-	public void setup() throws Exception {
-		ExecutionFlow flow = models
-				.loadExecutionFlowFromResource("ValuedEvents.sct");
-		initInterpreter(flow);
-	}
-	@Test
-	public void valuedEventTest() 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 ValuedEventTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("ValuedEvents.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void valuedEventTest() throws Exception {
+		interpreter.enter();
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(isActive("C"));
+		assertTrue(getInteger("myVar") == 42);
+	}
+}

test-plugins/org.yakindu.sct.model.sexec.interpreter.test/src/org/yakindu/sct/model/sexec/interpreter/test/STextInterpreterTest.java

@@ -18,12 +18,14 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.yakindu.base.types.ITypeSystem.InferredType;
 import org.yakindu.sct.model.sexec.interpreter.stext.StextStatementInterpreter;
 import org.yakindu.sct.model.sgraph.Scope;
 import org.yakindu.sct.model.sgraph.Statement;
 import org.yakindu.sct.model.stext.stext.Expression;
 import org.yakindu.sct.model.stext.test.util.AbstractSTextTest;
 import org.yakindu.sct.model.stext.test.util.STextInjectorProvider;
+import org.yakindu.sct.model.stext.types.ISTextTypeSystem;
 import org.yakindu.sct.simulation.core.runtime.IExecutionContext;
 import org.yakindu.sct.simulation.core.runtime.impl.ExecutionContextImpl;
 import org.yakindu.sct.simulation.core.runtime.impl.ExecutionEvent;
@@ -44,6 +46,8 @@ public class STextInterpreterTest extends AbstractSTextTest {
 	private ExecutionContextImpl context;
 	@Inject
 	private StextStatementInterpreter interpreter;
+	@Inject
+	private ISTextTypeSystem typeSystem;
 
 	@Test
 	public void testIntVariableAssignment() {
@@ -471,19 +475,19 @@ public class STextInterpreterTest extends AbstractSTextTest {
 	private void initContext() {
 		// "event abc operation foo() var intVar : integer var boolVar : boolean
 		// var realVar : real
-		ExecutionVariable intVar = new ExecutionVariable("intVar", Integer.class,
+		ExecutionVariable intVar = new ExecutionVariable("intVar", new InferredType(typeSystem.getIntegerType()),
 				0);
 		context.declareVariable(intVar);
 		ExecutionVariable boolVar = new ExecutionVariable("boolVar",
-				Boolean.class, false);
+				new InferredType(typeSystem.getBooleanType()), false);
 		context.declareVariable(boolVar);
-		ExecutionVariable realVar = new ExecutionVariable("realVar", Float.class,
+		ExecutionVariable realVar = new ExecutionVariable("realVar", new InferredType(typeSystem.getRealType()),
 				0.0f);
 		context.declareVariable(realVar);
 		ExecutionVariable stringVar = new ExecutionVariable("stringVar",
-				String.class, "");
+				new InferredType(typeSystem.getStringType()), "");
 		context.declareVariable(stringVar);
-		ExecutionEvent event = new ExecutionEvent("abc", Integer.class);
+		ExecutionEvent event = new ExecutionEvent("abc", new InferredType(typeSystem.getIntegerType()));
 		context.declareEvent(event);
 	}