Change generated name of unnamed interface.

Examples/org.yakindu.sct.generator.java.trafficlight/src-gen/org/yakindu/sct/runtime/java/trafficlightwaiting/InterfaceDefault.java

@@ -10,7 +10,7 @@
  */
 package org.yakindu.sct.runtime.java.trafficlightwaiting;
 
-public interface InterfaceDefault {
+public interface DefaultInterface {
 
 	public void raiseKeypress1();
 	public void raiseKeypress2();

Examples/org.yakindu.sct.generator.java.trafficlight/src-gen/org/yakindu/sct/runtime/java/trafficlightwaiting/InterfaceDefaultImpl.java

@@ -12,7 +12,7 @@ package org.yakindu.sct.runtime.java.trafficlightwaiting;
 
 import org.yakindu.sct.runtime.java.Event;
 
-public class InterfaceDefaultImpl implements InterfaceDefault {
+public class DefaultInterfaceImpl implements DefaultInterface {
 
 	private final Event EventKeypress1 = new Event("keypress1");
 	private final Event EventKeypress2 = new Event("keypress2");
@@ -20,7 +20,7 @@ public class InterfaceDefaultImpl implements InterfaceDefault {
 
 	private TrafficLightWaitingCycleBasedStatemachine statemachine;
 
-	public InterfaceDefaultImpl(
+	public DefaultInterfaceImpl(
 			TrafficLightWaitingCycleBasedStatemachine statemachine) {
 		this.statemachine = statemachine;
 	}

Examples/org.yakindu.sct.generator.java.trafficlight/src-gen/org/yakindu/sct/runtime/java/trafficlightwaiting/TrafficLightWaitingCycleBasedStatemachine.java

@@ -51,7 +51,7 @@ public class TrafficLightWaitingCycleBasedStatemachine
 
 	private InterfaceTrafficLightImpl interfaceTrafficLight;
 	private InterfacePedestrianImpl interfacePedestrian;
-	private InterfaceDefaultImpl interfaceDefault;
+	private DefaultInterfaceImpl defaultInterface;
 
 	private final Set<State> activeStates = EnumSet.noneOf(State.class);
 
@@ -68,7 +68,7 @@ public class TrafficLightWaitingCycleBasedStatemachine
 		outEvents = new HashSet<Event>();
 		interfaceTrafficLight = new InterfaceTrafficLightImpl(this);
 		interfacePedestrian = new InterfacePedestrianImpl(this);
-		interfaceDefault = new InterfaceDefaultImpl(this);
+		defaultInterface = new DefaultInterfaceImpl(this);
 	}
 
 	protected Collection<Event> getOccuredEvents() {
@@ -118,8 +118,8 @@ public class TrafficLightWaitingCycleBasedStatemachine
 		return interfacePedestrian;
 	}
 
-	public InterfaceDefault getInterfaceDefault() {
-		return interfaceDefault;
+	public DefaultInterface getDefaultInterface() {
+		return defaultInterface;
 	}
 
 	public void enter() {
@@ -128,13 +128,13 @@ public class TrafficLightWaitingCycleBasedStatemachine
 	}
 
 	private boolean conditionOnTr0() {
-		return occuredEvents.contains(interfaceDefault.getEventKeypress3());
+		return occuredEvents.contains(defaultInterface.getEventKeypress3());
 	}
 	private boolean conditionOnTr1() {
-		return occuredEvents.contains(interfaceDefault.getEventKeypress2());
+		return occuredEvents.contains(defaultInterface.getEventKeypress2());
 	}
 	private boolean conditionStreetGreenTr0() {
-		return occuredEvents.contains(interfaceDefault.getEventKeypress1());
+		return occuredEvents.contains(defaultInterface.getEventKeypress1());
 	}
 	private boolean conditionPedWaitingTr0() {
 		return occuredEvents.contains(PedWaiting_time_event_0);
@@ -161,10 +161,10 @@ public class TrafficLightWaitingCycleBasedStatemachine
 		return occuredEvents.contains(StreetPrepare_time_event_0);
 	}
 	private boolean conditionFreezeTr0() {
-		return occuredEvents.contains(interfaceDefault.getEventKeypress3());
+		return occuredEvents.contains(defaultInterface.getEventKeypress3());
 	}
 	private boolean conditionOffTr0() {
-		return occuredEvents.contains(interfaceDefault.getEventKeypress2());
+		return occuredEvents.contains(defaultInterface.getEventKeypress2());
 	}
 	private boolean conditionBlinkYellowLr1() {
 		return occuredEvents.contains(BlinkYellow_time_event_0);

Examples/org.yakindu.sct.generator.java.trafficlight/src/org/yakindu/sct/examples/java/trafficlight/CrossingDemo.java

@@ -150,10 +150,10 @@ public class CrossingDemo {
 					// Shorter call for code commented out below
 					try {
 						Class<?> interfaceClass = statemachine
-								.getInterfaceDefault().getClass();
+								.getDefaultInterface().getClass();
 						interfaceClass.getDeclaredMethod(
 								"raiseKeypress" + (j + 1), new Class[0])
-								.invoke(statemachine.getInterfaceDefault(),
+								.invoke(statemachine.getDefaultInterface(),
 										new Object[0]);
 					} catch (IllegalAccessException e) {
 						e.printStackTrace();

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/templates/Naming.ext

@@ -39,7 +39,7 @@ String getInterfaceName(InterfaceScope this) :
 	if name!=null then
 		"Interface" + name.toFirstUpper()
 	else
-		"InterfaceDefault";
+		"DefaultInterface";
 		 
 String getInterfaceImplName(InterfaceScope this) :  getInterfaceName() + "Impl";
 

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/interfacetest/InterfaceDefault.java

@@ -13,7 +13,7 @@ package org.yakindu.sct.runtime.java.interfacetest;
 import org.yakindu.sct.runtime.java.INotificationSender;
 import org.yakindu.sct.runtime.java.ValuedEvent;
 
-public interface InterfaceDefault extends INotificationSender {
+public interface DefaultInterface extends INotificationSender {
 
 	public void raiseEvent1();
 	public boolean isRaisedEvent2();

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/interfacetest/InterfaceDefaultImpl.java

@@ -15,9 +15,9 @@ import org.yakindu.sct.runtime.java.EventNotification;
 import org.yakindu.sct.runtime.java.NotificationSender;
 import org.yakindu.sct.runtime.java.ValuedEvent;
 
-public class InterfaceDefaultImpl extends NotificationSender
+public class DefaultInterfaceImpl extends NotificationSender
 		implements
-			InterfaceDefault {
+			DefaultInterface {
 
 	private final Event EventEvent1 = new Event("event1");
 	private final ValuedEvent<Integer> EventEvent2 = new ValuedEvent<Integer>(
@@ -25,7 +25,7 @@ public class InterfaceDefaultImpl extends NotificationSender
 
 	private InterfaceTestCycleBasedStatemachine statemachine;
 
-	public InterfaceDefaultImpl(InterfaceTestCycleBasedStatemachine statemachine) {
+	public DefaultInterfaceImpl(InterfaceTestCycleBasedStatemachine statemachine) {
 		this.statemachine = statemachine;
 	}
 

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/interfacetest/Interface.java

@@ -0,0 +1,29 @@
+/**
+ * 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.runtime.java.interfacetest;
+
+import org.yakindu.sct.runtime.java.INotificationSender;
+import org.yakindu.sct.runtime.java.ValuedEvent;
+
+public interface Interface extends INotificationSender {
+
+	public void raiseEvent1();
+	public boolean isRaisedEvent2();
+
+	public ValuedEvent<Integer> getEventEvent2();
+
+	public boolean getVarVar1();
+	public void setVarVar1(boolean value);
+	public double getVarVar2();
+	public void setVarVar2(double value);
+	public int getVarVar3();
+	public void setVarVar3(int value);
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/interfacetest/InterfaceImpl.java

@@ -0,0 +1,86 @@
+/**
+ * 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.runtime.java.interfacetest;
+
+import org.yakindu.sct.runtime.java.Event;
+import org.yakindu.sct.runtime.java.EventNotification;
+import org.yakindu.sct.runtime.java.NotificationSender;
+import org.yakindu.sct.runtime.java.ValuedEvent;
+
+public class InterfaceImpl extends NotificationSender implements Interface {
+
+	private final Event EventEvent1 = new Event("event1");
+	private final ValuedEvent<Integer> EventEvent2 = new ValuedEvent<Integer>(
+			"event2", 0);
+
+	private InterfaceTestCycleBasedStatemachine statemachine;
+
+	public InterfaceImpl(InterfaceTestCycleBasedStatemachine statemachine) {
+		this.statemachine = statemachine;
+	}
+
+	public void raiseEvent1() {
+		statemachine.getOccuredEvents().add(EventEvent1);
+	}
+
+	public Event getEventEvent1() {
+		return EventEvent1;
+	}
+
+	public void raiseEvent2() {
+		statemachine.getOccuredEvents().add(EventEvent2);
+		statemachine.getOutEvents().add(EventEvent2);
+		notifyListeners(new EventNotification(EventEvent2));
+	}
+
+	public void raiseEvent2(int value) {
+		EventEvent2.setValue(value);
+		statemachine.getOccuredEvents().add(EventEvent2);
+		statemachine.getOutEvents().add(EventEvent2);
+		notifyListeners(new EventNotification(EventEvent2));
+	}
+
+	public ValuedEvent<Integer> getEventEvent2() {
+		return EventEvent2;
+	}
+
+	public boolean isRaisedEvent2() {
+		return statemachine.getOutEvents().contains(EventEvent2);
+	}
+
+	private boolean varVar1;
+
+	public boolean getVarVar1() {
+		return varVar1;
+	}
+
+	public void setVarVar1(boolean value) {
+		varVar1 = value;
+	}
+	private double varVar2 = 2.3;
+
+	public double getVarVar2() {
+		return varVar2;
+	}
+
+	public void setVarVar2(double value) {
+		varVar2 = value;
+	}
+	private int varVar3 = 1;
+
+	public int getVarVar3() {
+		return varVar3;
+	}
+
+	public void setVarVar3(int value) {
+		varVar3 = value;
+	}
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/interfacetest/InterfaceTestCycleBasedStatemachine.java

@@ -24,7 +24,7 @@ public class InterfaceTestCycleBasedStatemachine implements IStatemachine {
 		State1, State2, State3, State4,
 	};
 
-	private InterfaceDefaultImpl interfaceDefault;
+	private DefaultInterfaceImpl defaultInterface;
 	private InterfaceOtherImpl interfaceOther;
 	private InterfaceThirdImpl interfaceThird;
 
@@ -37,7 +37,7 @@ public class InterfaceTestCycleBasedStatemachine implements IStatemachine {
 	public InterfaceTestCycleBasedStatemachine() {
 		occuredEvents = new ArrayList<Event>();
 		outEvents = new HashSet<Event>();
-		interfaceDefault = new InterfaceDefaultImpl(this);
+		defaultInterface = new DefaultInterfaceImpl(this);
 		interfaceOther = new InterfaceOtherImpl(this);
 		interfaceThird = new InterfaceThirdImpl(this);
 	}
@@ -62,8 +62,8 @@ public class InterfaceTestCycleBasedStatemachine implements IStatemachine {
 		return EnumSet.copyOf(activeStates);
 	}
 
-	public InterfaceDefault getInterfaceDefault() {
-		return interfaceDefault;
+	public DefaultInterface getDefaultInterface() {
+		return defaultInterface;
 	}
 
 	public InterfaceOther getInterfaceOther() {
@@ -79,19 +79,19 @@ public class InterfaceTestCycleBasedStatemachine implements IStatemachine {
 	}
 
 	private boolean conditionState1Tr0() {
-		return (occuredEvents.contains(interfaceDefault.getEventEvent1()) && (interfaceDefault
+		return (occuredEvents.contains(defaultInterface.getEventEvent1()) && (defaultInterface
 				.getVarVar2() > 0));
 	}
 	private boolean conditionState1Tr1() {
-		return (occuredEvents.contains(interfaceOther.getEventEvent3()) && (interfaceDefault
+		return (occuredEvents.contains(interfaceOther.getEventEvent3()) && (defaultInterface
 				.getVarVar3() == 1));
 	}
 	private boolean conditionState1Tr2() {
-		return (occuredEvents.contains(interfaceThird.getEventEvent5()) && (interfaceDefault
+		return (occuredEvents.contains(interfaceThird.getEventEvent5()) && (defaultInterface
 				.getVarVar1() == true));
 	}
 	private boolean conditionState2Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent1());
+		return occuredEvents.contains(defaultInterface.getEventEvent1());
 	}
 	private boolean conditionState3Tr0() {
 		return occuredEvents.contains(interfaceOther.getEventEvent3());
@@ -130,7 +130,7 @@ public class InterfaceTestCycleBasedStatemachine implements IStatemachine {
 
 	}
 	private void entryActionState2() {
-		interfaceDefault.raiseEvent2(22);
+		defaultInterface.raiseEvent2(22);
 
 	}
 	private void entryActionState3() {

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_deephistory/InterfaceDefault.java

@@ -10,7 +10,7 @@
  */
 package org.yakindu.sct.runtime.java.test_deephistory;
 
-public interface InterfaceDefault {
+public interface DefaultInterface {
 
 	public void raiseEvent1();
 	public void raiseEvent2();

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_deephistory/InterfaceDefaultImpl.java

@@ -12,7 +12,7 @@ package org.yakindu.sct.runtime.java.test_deephistory;
 
 import org.yakindu.sct.runtime.java.Event;
 
-public class InterfaceDefaultImpl implements InterfaceDefault {
+public class DefaultInterfaceImpl implements DefaultInterface {
 
 	private final Event EventEvent1 = new Event("event1");
 	private final Event EventEvent2 = new Event("event2");
@@ -26,7 +26,7 @@ public class InterfaceDefaultImpl implements InterfaceDefault {
 
 	private Test_DeepHistoryCycleBasedStatemachine statemachine;
 
-	public InterfaceDefaultImpl(
+	public DefaultInterfaceImpl(
 			Test_DeepHistoryCycleBasedStatemachine statemachine) {
 		this.statemachine = statemachine;
 	}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_deephistory/Interface.java

@@ -0,0 +1,25 @@
+/**
+ * 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.runtime.java.test_deephistory;
+
+public interface Interface {
+
+	public void raiseEvent1();
+	public void raiseEvent2();
+	public void raiseEvent3();
+	public void raiseEvent4();
+	public void raiseEvent5();
+	public void raiseEvent6();
+	public void raiseEvent7();
+	public void raiseEvent8();
+	public void raiseEvent9();
+
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_deephistory/InterfaceImpl.java

@@ -0,0 +1,105 @@
+/**
+ * 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.runtime.java.test_deephistory;
+
+import org.yakindu.sct.runtime.java.Event;
+
+public class InterfaceImpl implements Interface {
+
+	private final Event EventEvent1 = new Event("event1");
+	private final Event EventEvent2 = new Event("event2");
+	private final Event EventEvent3 = new Event("event3");
+	private final Event EventEvent4 = new Event("event4");
+	private final Event EventEvent5 = new Event("event5");
+	private final Event EventEvent6 = new Event("event6");
+	private final Event EventEvent7 = new Event("event7");
+	private final Event EventEvent8 = new Event("event8");
+	private final Event EventEvent9 = new Event("event9");
+
+	private Test_DeepHistoryCycleBasedStatemachine statemachine;
+
+	public InterfaceImpl(Test_DeepHistoryCycleBasedStatemachine statemachine) {
+		this.statemachine = statemachine;
+	}
+
+	public void raiseEvent1() {
+		statemachine.getOccuredEvents().add(EventEvent1);
+	}
+
+	public Event getEventEvent1() {
+		return EventEvent1;
+	}
+
+	public void raiseEvent2() {
+		statemachine.getOccuredEvents().add(EventEvent2);
+	}
+
+	public Event getEventEvent2() {
+		return EventEvent2;
+	}
+
+	public void raiseEvent3() {
+		statemachine.getOccuredEvents().add(EventEvent3);
+	}
+
+	public Event getEventEvent3() {
+		return EventEvent3;
+	}
+
+	public void raiseEvent4() {
+		statemachine.getOccuredEvents().add(EventEvent4);
+	}
+
+	public Event getEventEvent4() {
+		return EventEvent4;
+	}
+
+	public void raiseEvent5() {
+		statemachine.getOccuredEvents().add(EventEvent5);
+	}
+
+	public Event getEventEvent5() {
+		return EventEvent5;
+	}
+
+	public void raiseEvent6() {
+		statemachine.getOccuredEvents().add(EventEvent6);
+	}
+
+	public Event getEventEvent6() {
+		return EventEvent6;
+	}
+
+	public void raiseEvent7() {
+		statemachine.getOccuredEvents().add(EventEvent7);
+	}
+
+	public Event getEventEvent7() {
+		return EventEvent7;
+	}
+
+	public void raiseEvent8() {
+		statemachine.getOccuredEvents().add(EventEvent8);
+	}
+
+	public Event getEventEvent8() {
+		return EventEvent8;
+	}
+
+	public void raiseEvent9() {
+		statemachine.getOccuredEvents().add(EventEvent9);
+	}
+
+	public Event getEventEvent9() {
+		return EventEvent9;
+	}
+
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_deephistory/Test_DeepHistoryCycleBasedStatemachine.java

@@ -24,7 +24,7 @@ public class Test_DeepHistoryCycleBasedStatemachine implements IStatemachine {
 		State1, State2, State3, State4, State6, State7, State8, State9, State5,
 	};
 
-	private InterfaceDefaultImpl interfaceDefault;
+	private DefaultInterfaceImpl defaultInterface;
 
 	private final Set<State> activeStates = EnumSet.noneOf(State.class);
 
@@ -35,7 +35,7 @@ public class Test_DeepHistoryCycleBasedStatemachine implements IStatemachine {
 	public Test_DeepHistoryCycleBasedStatemachine() {
 		occuredEvents = new ArrayList<Event>();
 		outEvents = new HashSet<Event>();
-		interfaceDefault = new InterfaceDefaultImpl(this);
+		defaultInterface = new DefaultInterfaceImpl(this);
 	}
 
 	protected Collection<Event> getOccuredEvents() {
@@ -58,8 +58,8 @@ public class Test_DeepHistoryCycleBasedStatemachine implements IStatemachine {
 		return EnumSet.copyOf(activeStates);
 	}
 
-	public InterfaceDefault getInterfaceDefault() {
-		return interfaceDefault;
+	public DefaultInterface getDefaultInterface() {
+		return defaultInterface;
 	}
 
 	public void enter() {
@@ -67,28 +67,28 @@ public class Test_DeepHistoryCycleBasedStatemachine implements IStatemachine {
 	}
 
 	private boolean conditionState1Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent1());
+		return occuredEvents.contains(defaultInterface.getEventEvent1());
 	}
 	private boolean conditionState2Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent2());
+		return occuredEvents.contains(defaultInterface.getEventEvent2());
 	}
 	private boolean conditionState3Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent3());
+		return occuredEvents.contains(defaultInterface.getEventEvent3());
 	}
 	private boolean conditionState4Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent4());
+		return occuredEvents.contains(defaultInterface.getEventEvent4());
 	}
 	private boolean conditionState6Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent5());
+		return occuredEvents.contains(defaultInterface.getEventEvent5());
 	}
 	private boolean conditionState7Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent6());
+		return occuredEvents.contains(defaultInterface.getEventEvent6());
 	}
 	private boolean conditionState8Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent7());
+		return occuredEvents.contains(defaultInterface.getEventEvent7());
 	}
 	private boolean conditionState9Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent8());
+		return occuredEvents.contains(defaultInterface.getEventEvent8());
 	}
 	private void actionsState1Tr0() {
 		exitSequenceState1();

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_expression/InterfaceDefault.java

@@ -13,7 +13,7 @@ package org.yakindu.sct.runtime.java.test_expression;
 import org.yakindu.sct.runtime.java.INotificationSender;
 import org.yakindu.sct.runtime.java.ValuedEvent;
 
-public interface InterfaceDefault extends INotificationSender {
+public interface DefaultInterface extends INotificationSender {
 
 	public void raiseEvent1();
 	public void raiseEvent1(int value);

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_expression/InterfaceDefaultImpl.java

@@ -14,9 +14,9 @@ import org.yakindu.sct.runtime.java.EventNotification;
 import org.yakindu.sct.runtime.java.NotificationSender;
 import org.yakindu.sct.runtime.java.ValuedEvent;
 
-public class InterfaceDefaultImpl extends NotificationSender
+public class DefaultInterfaceImpl extends NotificationSender
 		implements
-			InterfaceDefault {
+			DefaultInterface {
 
 	private final ValuedEvent<Integer> EventEvent1 = new ValuedEvent<Integer>(
 			"event1", 0);
@@ -25,7 +25,7 @@ public class InterfaceDefaultImpl extends NotificationSender
 
 	private Test_ExpressionCycleBasedStatemachine statemachine;
 
-	public InterfaceDefaultImpl(
+	public DefaultInterfaceImpl(
 			Test_ExpressionCycleBasedStatemachine statemachine) {
 		this.statemachine = statemachine;
 	}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_expression/Interface.java

@@ -0,0 +1,34 @@
+/**
+ * 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.runtime.java.test_expression;
+
+import org.yakindu.sct.runtime.java.INotificationSender;
+import org.yakindu.sct.runtime.java.ValuedEvent;
+
+public interface Interface extends INotificationSender {
+
+	public void raiseEvent1();
+	public void raiseEvent1(int value);
+	public boolean isRaisedEvent2();
+
+	public ValuedEvent<Double> getEventEvent2();
+
+	public int getVarVar1();
+	public void setVarVar1(int value);
+	public int getVarVar2();
+	public void setVarVar2(int value);
+	public double getVarVar3();
+	public void setVarVar3(double value);
+	public double getVarVar4();
+	public void setVarVar4(double value);
+	public boolean getVarVar5();
+	public void setVarVar5(boolean value);
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_expression/InterfaceImpl.java

@@ -0,0 +1,109 @@
+/**
+ * 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.runtime.java.test_expression;
+
+import org.yakindu.sct.runtime.java.EventNotification;
+import org.yakindu.sct.runtime.java.NotificationSender;
+import org.yakindu.sct.runtime.java.ValuedEvent;
+
+public class InterfaceImpl extends NotificationSender implements Interface {
+
+	private final ValuedEvent<Integer> EventEvent1 = new ValuedEvent<Integer>(
+			"event1", 0);
+	private final ValuedEvent<Double> EventEvent2 = new ValuedEvent<Double>(
+			"event2", 0D);
+
+	private Test_ExpressionCycleBasedStatemachine statemachine;
+
+	public InterfaceImpl(Test_ExpressionCycleBasedStatemachine statemachine) {
+		this.statemachine = statemachine;
+	}
+
+	public void raiseEvent1() {
+		statemachine.getOccuredEvents().add(EventEvent1);
+	}
+
+	public void raiseEvent1(int value) {
+		EventEvent1.setValue(value);
+		statemachine.getOccuredEvents().add(EventEvent1);
+	}
+
+	public ValuedEvent<Integer> getEventEvent1() {
+		return EventEvent1;
+	}
+
+	public void raiseEvent2() {
+		statemachine.getOccuredEvents().add(EventEvent2);
+		statemachine.getOutEvents().add(EventEvent2);
+		notifyListeners(new EventNotification(EventEvent2));
+	}
+
+	public void raiseEvent2(double value) {
+		EventEvent2.setValue(value);
+		statemachine.getOccuredEvents().add(EventEvent2);
+		statemachine.getOutEvents().add(EventEvent2);
+		notifyListeners(new EventNotification(EventEvent2));
+	}
+
+	public ValuedEvent<Double> getEventEvent2() {
+		return EventEvent2;
+	}
+
+	public boolean isRaisedEvent2() {
+		return statemachine.getOutEvents().contains(EventEvent2);
+	}
+
+	private int varVar1 = 6;
+
+	public int getVarVar1() {
+		return varVar1;
+	}
+
+	public void setVarVar1(int value) {
+		varVar1 = value;
+	}
+	private int varVar2 = 123;
+
+	public int getVarVar2() {
+		return varVar2;
+	}
+
+	public void setVarVar2(int value) {
+		varVar2 = value;
+	}
+	private double varVar3 = 19.4;
+
+	public double getVarVar3() {
+		return varVar3;
+	}
+
+	public void setVarVar3(double value) {
+		varVar3 = value;
+	}
+	private double varVar4 = 43.3;
+
+	public double getVarVar4() {
+		return varVar4;
+	}
+
+	public void setVarVar4(double value) {
+		varVar4 = value;
+	}
+	private boolean varVar5 = false;
+
+	public boolean getVarVar5() {
+		return varVar5;
+	}
+
+	public void setVarVar5(boolean value) {
+		varVar5 = value;
+	}
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_expression/Test_ExpressionCycleBasedStatemachine.java

@@ -24,7 +24,7 @@ public class Test_ExpressionCycleBasedStatemachine implements IStatemachine {
 		State1, State2,
 	};
 
-	private InterfaceDefaultImpl interfaceDefault;
+	private DefaultInterfaceImpl defaultInterface;
 	private InterfaceOtherImpl interfaceOther;
 
 	private final Set<State> activeStates = EnumSet.noneOf(State.class);
@@ -36,7 +36,7 @@ public class Test_ExpressionCycleBasedStatemachine implements IStatemachine {
 	public Test_ExpressionCycleBasedStatemachine() {
 		occuredEvents = new ArrayList<Event>();
 		outEvents = new HashSet<Event>();
-		interfaceDefault = new InterfaceDefaultImpl(this);
+		defaultInterface = new DefaultInterfaceImpl(this);
 		interfaceOther = new InterfaceOtherImpl(this);
 	}
 
@@ -60,8 +60,8 @@ public class Test_ExpressionCycleBasedStatemachine implements IStatemachine {
 		return EnumSet.copyOf(activeStates);
 	}
 
-	public InterfaceDefault getInterfaceDefault() {
-		return interfaceDefault;
+	public DefaultInterface getDefaultInterface() {
+		return defaultInterface;
 	}
 
 	public InterfaceOther getInterfaceOther() {
@@ -73,11 +73,11 @@ public class Test_ExpressionCycleBasedStatemachine implements IStatemachine {
 	}
 
 	private boolean conditionState1Tr0() {
-		return (occuredEvents.contains(interfaceDefault.getEventEvent1()) && ((interfaceOther
-				.getVarVar1() == true) || (interfaceDefault.getVarVar5() == false)));
+		return (occuredEvents.contains(defaultInterface.getEventEvent1()) && ((interfaceOther
+				.getVarVar1() == true) || (defaultInterface.getVarVar5() == false)));
 	}
 	private boolean conditionState2Tr0() {
-		return (occuredEvents.contains(interfaceDefault.getEventEvent1()) && (interfaceDefault
+		return (occuredEvents.contains(defaultInterface.getEventEvent1()) && (defaultInterface
 				.getVarVar3() > 0));
 	}
 	private boolean conditionState2Lr2() {
@@ -92,31 +92,31 @@ public class Test_ExpressionCycleBasedStatemachine implements IStatemachine {
 	}
 	private void actionsState2Tr0() {
 		exitSequenceState2();
-		interfaceDefault.setVarVar5(true);
+		defaultInterface.setVarVar5(true);
 
 		enterSequenceState1();
 
 	}
 	private void actionsState2Lr2() {
-		interfaceDefault.setVarVar1(interfaceDefault.getVarVar1() + (1));
+		defaultInterface.setVarVar1(defaultInterface.getVarVar1() + (1));
 
 	}
 	private void entryActionState1() {
-		interfaceDefault.setVarVar3(interfaceDefault.getVarVar3()
-				+ ((interfaceDefault.getVarVar2() * interfaceDefault
+		defaultInterface.setVarVar3(defaultInterface.getVarVar3()
+				+ ((defaultInterface.getVarVar2() * defaultInterface
 						.getVarVar3())));
 
 	}
 	private void entryActionState2() {
-		interfaceDefault.setVarVar3(interfaceDefault.getVarVar3() / (5));
+		defaultInterface.setVarVar3(defaultInterface.getVarVar3() / (5));
 
-		interfaceDefault.setVarVar1(interfaceDefault.getVarVar1() + (1));
+		defaultInterface.setVarVar1(defaultInterface.getVarVar1() + (1));
 
 	}
 	private void exitActionState1() {
-		interfaceDefault.setVarVar2(1);
+		defaultInterface.setVarVar2(1);
 
-		interfaceDefault.setVarVar4(22.3);
+		defaultInterface.setVarVar4(22.3);
 
 	}
 

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_hierarchy/InterfaceDefault.java

@@ -10,7 +10,7 @@
  */
 package org.yakindu.sct.runtime.java.test_hierarchy;
 
-public interface InterfaceDefault {
+public interface DefaultInterface {
 
 	public void raiseEvent1();
 	public void raiseEvent2();

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_hierarchy/InterfaceDefaultImpl.java

@@ -12,7 +12,7 @@ package org.yakindu.sct.runtime.java.test_hierarchy;
 
 import org.yakindu.sct.runtime.java.Event;
 
-public class InterfaceDefaultImpl implements InterfaceDefault {
+public class DefaultInterfaceImpl implements DefaultInterface {
 
 	private final Event EventEvent1 = new Event("event1");
 	private final Event EventEvent2 = new Event("event2");
@@ -33,7 +33,7 @@ public class InterfaceDefaultImpl implements InterfaceDefault {
 
 	private Test_HierarchyCycleBasedStatemachine statemachine;
 
-	public InterfaceDefaultImpl(
+	public DefaultInterfaceImpl(
 			Test_HierarchyCycleBasedStatemachine statemachine) {
 		this.statemachine = statemachine;
 	}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_hierarchy/Interface.java

@@ -0,0 +1,36 @@
+/**
+ * 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.runtime.java.test_hierarchy;
+
+public interface Interface {
+
+	public void raiseEvent1();
+	public void raiseEvent2();
+	public void raiseEvent3();
+	public void raiseEvent4();
+	public void raiseEvent5();
+	public void raiseEvent6();
+	public void raiseEvent7();
+	public void raiseEvent8();
+	public void raiseEvent9();
+	public void raiseEvent10();
+	public void raiseEvent11();
+	public void raiseEvent12();
+	public void raiseEvent13();
+	public void raiseEvent14();
+	public void raiseEvent15();
+	public void raiseEvent16();
+
+	public int getVarS1();
+	public void setVarS1(int value);
+	public int getVarS2();
+	public void setVarS2(int value);
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_hierarchy/InterfaceImpl.java

@@ -0,0 +1,186 @@
+/**
+ * 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.runtime.java.test_hierarchy;
+
+import org.yakindu.sct.runtime.java.Event;
+
+public class InterfaceImpl implements Interface {
+
+	private final Event EventEvent1 = new Event("event1");
+	private final Event EventEvent2 = new Event("event2");
+	private final Event EventEvent3 = new Event("event3");
+	private final Event EventEvent4 = new Event("event4");
+	private final Event EventEvent5 = new Event("event5");
+	private final Event EventEvent6 = new Event("event6");
+	private final Event EventEvent7 = new Event("event7");
+	private final Event EventEvent8 = new Event("event8");
+	private final Event EventEvent9 = new Event("event9");
+	private final Event EventEvent10 = new Event("event10");
+	private final Event EventEvent11 = new Event("event11");
+	private final Event EventEvent12 = new Event("event12");
+	private final Event EventEvent13 = new Event("event13");
+	private final Event EventEvent14 = new Event("event14");
+	private final Event EventEvent15 = new Event("event15");
+	private final Event EventEvent16 = new Event("event16");
+
+	private Test_HierarchyCycleBasedStatemachine statemachine;
+
+	public InterfaceImpl(Test_HierarchyCycleBasedStatemachine statemachine) {
+		this.statemachine = statemachine;
+	}
+
+	public void raiseEvent1() {
+		statemachine.getOccuredEvents().add(EventEvent1);
+	}
+
+	public Event getEventEvent1() {
+		return EventEvent1;
+	}
+
+	public void raiseEvent2() {
+		statemachine.getOccuredEvents().add(EventEvent2);
+	}
+
+	public Event getEventEvent2() {
+		return EventEvent2;
+	}
+
+	public void raiseEvent3() {
+		statemachine.getOccuredEvents().add(EventEvent3);
+	}
+
+	public Event getEventEvent3() {
+		return EventEvent3;
+	}
+
+	public void raiseEvent4() {
+		statemachine.getOccuredEvents().add(EventEvent4);
+	}
+
+	public Event getEventEvent4() {
+		return EventEvent4;
+	}
+
+	public void raiseEvent5() {
+		statemachine.getOccuredEvents().add(EventEvent5);
+	}
+
+	public Event getEventEvent5() {
+		return EventEvent5;
+	}
+
+	public void raiseEvent6() {
+		statemachine.getOccuredEvents().add(EventEvent6);
+	}
+
+	public Event getEventEvent6() {
+		return EventEvent6;
+	}
+
+	public void raiseEvent7() {
+		statemachine.getOccuredEvents().add(EventEvent7);
+	}
+
+	public Event getEventEvent7() {
+		return EventEvent7;
+	}
+
+	public void raiseEvent8() {
+		statemachine.getOccuredEvents().add(EventEvent8);
+	}
+
+	public Event getEventEvent8() {
+		return EventEvent8;
+	}
+
+	public void raiseEvent9() {
+		statemachine.getOccuredEvents().add(EventEvent9);
+	}
+
+	public Event getEventEvent9() {
+		return EventEvent9;
+	}
+
+	public void raiseEvent10() {
+		statemachine.getOccuredEvents().add(EventEvent10);
+	}
+
+	public Event getEventEvent10() {
+		return EventEvent10;
+	}
+
+	public void raiseEvent11() {
+		statemachine.getOccuredEvents().add(EventEvent11);
+	}
+
+	public Event getEventEvent11() {
+		return EventEvent11;
+	}
+
+	public void raiseEvent12() {
+		statemachine.getOccuredEvents().add(EventEvent12);
+	}
+
+	public Event getEventEvent12() {
+		return EventEvent12;
+	}
+
+	public void raiseEvent13() {
+		statemachine.getOccuredEvents().add(EventEvent13);
+	}
+
+	public Event getEventEvent13() {
+		return EventEvent13;
+	}
+
+	public void raiseEvent14() {
+		statemachine.getOccuredEvents().add(EventEvent14);
+	}
+
+	public Event getEventEvent14() {
+		return EventEvent14;
+	}
+
+	public void raiseEvent15() {
+		statemachine.getOccuredEvents().add(EventEvent15);
+	}
+
+	public Event getEventEvent15() {
+		return EventEvent15;
+	}
+
+	public void raiseEvent16() {
+		statemachine.getOccuredEvents().add(EventEvent16);
+	}
+
+	public Event getEventEvent16() {
+		return EventEvent16;
+	}
+
+	private int varS1 = 0;
+
+	public int getVarS1() {
+		return varS1;
+	}
+
+	public void setVarS1(int value) {
+		varS1 = value;
+	}
+	private int varS2;
+
+	public int getVarS2() {
+		return varS2;
+	}
+
+	public void setVarS2(int value) {
+		varS2 = value;
+	}
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_hierarchy/Test_HierarchyCycleBasedStatemachine.java

@@ -24,7 +24,7 @@ public class Test_HierarchyCycleBasedStatemachine implements IStatemachine {
 		State1, State9, State10, State2, State3, State4, State5, State6, State7, State8,
 	};
 
-	private InterfaceDefaultImpl interfaceDefault;
+	private DefaultInterfaceImpl defaultInterface;
 
 	private final Set<State> activeStates = EnumSet.noneOf(State.class);
 
@@ -35,7 +35,7 @@ public class Test_HierarchyCycleBasedStatemachine implements IStatemachine {
 	public Test_HierarchyCycleBasedStatemachine() {
 		occuredEvents = new ArrayList<Event>();
 		outEvents = new HashSet<Event>();
-		interfaceDefault = new InterfaceDefaultImpl(this);
+		defaultInterface = new DefaultInterfaceImpl(this);
 	}
 
 	protected Collection<Event> getOccuredEvents() {
@@ -58,8 +58,8 @@ public class Test_HierarchyCycleBasedStatemachine implements IStatemachine {
 		return EnumSet.copyOf(activeStates);
 	}
 
-	public InterfaceDefault getInterfaceDefault() {
-		return interfaceDefault;
+	public DefaultInterface getDefaultInterface() {
+		return defaultInterface;
 	}
 
 	public void enter() {
@@ -67,52 +67,52 @@ public class Test_HierarchyCycleBasedStatemachine implements IStatemachine {
 	}
 
 	private boolean conditionState1Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent1());
+		return occuredEvents.contains(defaultInterface.getEventEvent1());
 	}
 	private boolean conditionState9Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent9());
+		return occuredEvents.contains(defaultInterface.getEventEvent9());
 	}
 	private boolean conditionState10Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent10());
+		return occuredEvents.contains(defaultInterface.getEventEvent10());
 	}
 	private boolean conditionState2Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent6());
+		return occuredEvents.contains(defaultInterface.getEventEvent6());
 	}
 	private boolean conditionState3Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent2());
+		return occuredEvents.contains(defaultInterface.getEventEvent2());
 	}
 	private boolean conditionState3Tr1() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent11());
+		return occuredEvents.contains(defaultInterface.getEventEvent11());
 	}
 	private boolean conditionState3Tr2() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent14());
+		return occuredEvents.contains(defaultInterface.getEventEvent14());
 	}
 	private boolean conditionState4Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent7());
+		return occuredEvents.contains(defaultInterface.getEventEvent7());
 	}
 	private boolean conditionState5Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent3());
+		return occuredEvents.contains(defaultInterface.getEventEvent3());
 	}
 	private boolean conditionState5Tr1() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent12());
+		return occuredEvents.contains(defaultInterface.getEventEvent12());
 	}
 	private boolean conditionState5Tr2() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent15());
+		return occuredEvents.contains(defaultInterface.getEventEvent15());
 	}
 	private boolean conditionState6Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent8());
+		return occuredEvents.contains(defaultInterface.getEventEvent8());
 	}
 	private boolean conditionState7Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent4());
+		return occuredEvents.contains(defaultInterface.getEventEvent4());
 	}
 	private boolean conditionState8Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent5());
+		return occuredEvents.contains(defaultInterface.getEventEvent5());
 	}
 	private boolean conditionState8Tr1() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent13());
+		return occuredEvents.contains(defaultInterface.getEventEvent13());
 	}
 	private boolean conditionState8Tr2() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent16());
+		return occuredEvents.contains(defaultInterface.getEventEvent16());
 	}
 	private void actionsState1Tr0() {
 		exitSequenceState1();
@@ -210,83 +210,83 @@ public class Test_HierarchyCycleBasedStatemachine implements IStatemachine {
 
 	}
 	private void entryActionState1() {
-		interfaceDefault.setVarS1(1);
+		defaultInterface.setVarS1(1);
 
 	}
 	private void entryActionState9() {
-		interfaceDefault.setVarS1(interfaceDefault.getVarS1() + (1));
+		defaultInterface.setVarS1(defaultInterface.getVarS1() + (1));
 
 	}
 	private void entryActionState10() {
-		interfaceDefault.setVarS1(interfaceDefault.getVarS1() + (1));
+		defaultInterface.setVarS1(defaultInterface.getVarS1() + (1));
 
 	}
 	private void entryActionState2() {
-		interfaceDefault.setVarS2(1);
+		defaultInterface.setVarS2(1);
 
 	}
 	private void entryActionState3() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() + (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() + (1));
 
 	}
 	private void entryActionState4() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() + (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() + (1));
 
 	}
 	private void entryActionState5() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() + (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() + (1));
 
 	}
 	private void entryActionState6() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() + (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() + (1));
 
 	}
 	private void entryActionState7() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() + (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() + (1));
 
 	}
 	private void entryActionState8() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() + (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() + (1));
 
 	}
 	private void exitActionState1() {
-		interfaceDefault.setVarS1(interfaceDefault.getVarS1() - (1));
+		defaultInterface.setVarS1(defaultInterface.getVarS1() - (1));
 
 	}
 	private void exitActionState9() {
-		interfaceDefault.setVarS1(interfaceDefault.getVarS1() - (1));
+		defaultInterface.setVarS1(defaultInterface.getVarS1() - (1));
 
 	}
 	private void exitActionState10() {
-		interfaceDefault.setVarS1(interfaceDefault.getVarS1() - (1));
+		defaultInterface.setVarS1(defaultInterface.getVarS1() - (1));
 
 	}
 	private void exitActionState2() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() - (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() - (1));
 
 	}
 	private void exitActionState3() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() - (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() - (1));
 
 	}
 	private void exitActionState4() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() - (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() - (1));
 
 	}
 	private void exitActionState5() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() - (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() - (1));
 
 	}
 	private void exitActionState6() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() - (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() - (1));
 
 	}
 	private void exitActionState7() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() - (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() - (1));
 
 	}
 	private void exitActionState8() {
-		interfaceDefault.setVarS2(interfaceDefault.getVarS2() - (1));
+		defaultInterface.setVarS2(defaultInterface.getVarS2() - (1));
 
 	}
 

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_localactions/InterfaceDefault.java

@@ -10,7 +10,7 @@
  */
 package org.yakindu.sct.runtime.java.test_localactions;
 
-public interface InterfaceDefault {
+public interface DefaultInterface {
 
 	public void raiseEvent1();
 	public void raiseEvent2();

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_localactions/InterfaceDefaultImpl.java

@@ -12,7 +12,7 @@ package org.yakindu.sct.runtime.java.test_localactions;
 
 import org.yakindu.sct.runtime.java.Event;
 
-public class InterfaceDefaultImpl implements InterfaceDefault {
+public class DefaultInterfaceImpl implements DefaultInterface {
 
 	private final Event EventEvent1 = new Event("Event1");
 	private final Event EventEvent2 = new Event("Event2");
@@ -21,7 +21,7 @@ public class InterfaceDefaultImpl implements InterfaceDefault {
 
 	private Test_LocalActionsCycleBasedStatemachine statemachine;
 
-	public InterfaceDefaultImpl(
+	public DefaultInterfaceImpl(
 			Test_LocalActionsCycleBasedStatemachine statemachine) {
 		this.statemachine = statemachine;
 	}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_localactions/Interface.java

@@ -0,0 +1,26 @@
+/**
+ * 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.runtime.java.test_localactions;
+
+public interface Interface {
+
+	public void raiseEvent1();
+	public void raiseEvent2();
+	public void raiseEvent3();
+	public void raiseEvent4();
+
+	public int getVarI();
+	public void setVarI(int value);
+	public int getVarJ();
+	public void setVarJ(int value);
+	public int getVarC();
+	public void setVarC(int value);
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_localactions/InterfaceImpl.java

@@ -0,0 +1,87 @@
+/**
+ * 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.runtime.java.test_localactions;
+
+import org.yakindu.sct.runtime.java.Event;
+
+public class InterfaceImpl implements Interface {
+
+	private final Event EventEvent1 = new Event("Event1");
+	private final Event EventEvent2 = new Event("Event2");
+	private final Event EventEvent3 = new Event("Event3");
+	private final Event EventEvent4 = new Event("Event4");
+
+	private Test_LocalActionsCycleBasedStatemachine statemachine;
+
+	public InterfaceImpl(Test_LocalActionsCycleBasedStatemachine statemachine) {
+		this.statemachine = statemachine;
+	}
+
+	public void raiseEvent1() {
+		statemachine.getOccuredEvents().add(EventEvent1);
+	}
+
+	public Event getEventEvent1() {
+		return EventEvent1;
+	}
+
+	public void raiseEvent2() {
+		statemachine.getOccuredEvents().add(EventEvent2);
+	}
+
+	public Event getEventEvent2() {
+		return EventEvent2;
+	}
+
+	public void raiseEvent3() {
+		statemachine.getOccuredEvents().add(EventEvent3);
+	}
+
+	public Event getEventEvent3() {
+		return EventEvent3;
+	}
+
+	public void raiseEvent4() {
+		statemachine.getOccuredEvents().add(EventEvent4);
+	}
+
+	public Event getEventEvent4() {
+		return EventEvent4;
+	}
+
+	private int varI;
+
+	public int getVarI() {
+		return varI;
+	}
+
+	public void setVarI(int value) {
+		varI = value;
+	}
+	private int varJ;
+
+	public int getVarJ() {
+		return varJ;
+	}
+
+	public void setVarJ(int value) {
+		varJ = value;
+	}
+	private int varC;
+
+	public int getVarC() {
+		return varC;
+	}
+
+	public void setVarC(int value) {
+		varC = value;
+	}
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_localactions/Test_LocalActionsCycleBasedStatemachine.java

@@ -35,7 +35,7 @@ public class Test_LocalActionsCycleBasedStatemachine
 		State1, State2,
 	};
 
-	private InterfaceDefaultImpl interfaceDefault;
+	private DefaultInterfaceImpl defaultInterface;
 
 	private final Set<State> activeStates = EnumSet.noneOf(State.class);
 
@@ -50,7 +50,7 @@ public class Test_LocalActionsCycleBasedStatemachine
 	public Test_LocalActionsCycleBasedStatemachine() {
 		occuredEvents = new ArrayList<Event>();
 		outEvents = new HashSet<Event>();
-		interfaceDefault = new InterfaceDefaultImpl(this);
+		defaultInterface = new DefaultInterfaceImpl(this);
 	}
 
 	protected Collection<Event> getOccuredEvents() {
@@ -92,8 +92,8 @@ public class Test_LocalActionsCycleBasedStatemachine
 		return EnumSet.copyOf(activeStates);
 	}
 
-	public InterfaceDefault getInterfaceDefault() {
-		return interfaceDefault;
+	public DefaultInterface getDefaultInterface() {
+		return defaultInterface;
 	}
 
 	public void enter() {
@@ -102,23 +102,23 @@ public class Test_LocalActionsCycleBasedStatemachine
 	}
 
 	private boolean conditionState1Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent1());
+		return occuredEvents.contains(defaultInterface.getEventEvent1());
 	}
 	private boolean conditionState1Lr2() {
 		return true;
 	}
 	private boolean conditionState1Lr3() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent2());
+		return occuredEvents.contains(defaultInterface.getEventEvent2());
 	}
 	private boolean conditionState1Lr4() {
 		return occuredEvents.contains(State1_time_event_0);
 	}
 	private boolean conditionState2Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent3());
+		return occuredEvents.contains(defaultInterface.getEventEvent3());
 	}
 	private boolean conditionState2Lr2() {
-		return (occuredEvents.contains(interfaceDefault.getEventEvent2()) || occuredEvents
-				.contains(interfaceDefault.getEventEvent4()));
+		return (occuredEvents.contains(defaultInterface.getEventEvent2()) || occuredEvents
+				.contains(defaultInterface.getEventEvent4()));
 	}
 	private boolean conditionState2Lr3() {
 		return occuredEvents.contains(State2_time_event_0);
@@ -129,15 +129,15 @@ public class Test_LocalActionsCycleBasedStatemachine
 
 	}
 	private void actionsState1Lr2() {
-		interfaceDefault.setVarI(2);
+		defaultInterface.setVarI(2);
 
 	}
 	private void actionsState1Lr3() {
-		interfaceDefault.setVarI(3);
+		defaultInterface.setVarI(3);
 
 	}
 	private void actionsState1Lr4() {
-		interfaceDefault.setVarC(interfaceDefault.getVarC() + (1));
+		defaultInterface.setVarC(defaultInterface.getVarC() + (1));
 
 	}
 	private void actionsState2Tr0() {
@@ -146,31 +146,31 @@ public class Test_LocalActionsCycleBasedStatemachine
 
 	}
 	private void actionsState2Lr2() {
-		interfaceDefault.setVarJ(2);
+		defaultInterface.setVarJ(2);
 
 	}
 	private void actionsState2Lr3() {
-		interfaceDefault.setVarJ(3);
+		defaultInterface.setVarJ(3);
 
 	}
 	private void entryActionState1() {
 		getTimerHandler().setTimer(State1_time_event_0, 100, cycleStartTime);
-		interfaceDefault.setVarI(1);
+		defaultInterface.setVarI(1);
 
 	}
 	private void entryActionState2() {
 		getTimerHandler().setTimer(State2_time_event_0, 200, cycleStartTime);
-		interfaceDefault.setVarJ(1);
+		defaultInterface.setVarJ(1);
 
 	}
 	private void exitActionState1() {
 		getTimerHandler().resetTimer(State1_time_event_0);
-		interfaceDefault.setVarI(0);
+		defaultInterface.setVarI(0);
 
 	}
 	private void exitActionState2() {
 		getTimerHandler().resetTimer(State2_time_event_0);
-		interfaceDefault.setVarJ(0);
+		defaultInterface.setVarJ(0);
 
 	}
 

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_parallelregions/InterfaceDefault.java

@@ -10,7 +10,7 @@
  */
 package org.yakindu.sct.runtime.java.test_parallelregions;
 
-public interface InterfaceDefault {
+public interface DefaultInterface {
 
 	public void raiseEvent1();
 	public void raiseEvent2();

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_parallelregions/InterfaceDefaultImpl.java

@@ -12,7 +12,7 @@ package org.yakindu.sct.runtime.java.test_parallelregions;
 
 import org.yakindu.sct.runtime.java.Event;
 
-public class InterfaceDefaultImpl implements InterfaceDefault {
+public class DefaultInterfaceImpl implements DefaultInterface {
 
 	private final Event EventEvent1 = new Event("event1");
 	private final Event EventEvent2 = new Event("event2");
@@ -23,7 +23,7 @@ public class InterfaceDefaultImpl implements InterfaceDefault {
 
 	private Test_ParallelRegionsCycleBasedStatemachine statemachine;
 
-	public InterfaceDefaultImpl(
+	public DefaultInterfaceImpl(
 			Test_ParallelRegionsCycleBasedStatemachine statemachine) {
 		this.statemachine = statemachine;
 	}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_parallelregions/Interface.java

@@ -0,0 +1,22 @@
+/**
+ * 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.runtime.java.test_parallelregions;
+
+public interface Interface {
+
+	public void raiseEvent1();
+	public void raiseEvent2();
+	public void raiseEvent3();
+	public void raiseEvent4();
+	public void raiseEvent5();
+	public void raiseEvent6();
+
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_parallelregions/InterfaceImpl.java

@@ -0,0 +1,78 @@
+/**
+ * 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.runtime.java.test_parallelregions;
+
+import org.yakindu.sct.runtime.java.Event;
+
+public class InterfaceImpl implements Interface {
+
+	private final Event EventEvent1 = new Event("event1");
+	private final Event EventEvent2 = new Event("event2");
+	private final Event EventEvent3 = new Event("event3");
+	private final Event EventEvent4 = new Event("event4");
+	private final Event EventEvent5 = new Event("event5");
+	private final Event EventEvent6 = new Event("event6");
+
+	private Test_ParallelRegionsCycleBasedStatemachine statemachine;
+
+	public InterfaceImpl(Test_ParallelRegionsCycleBasedStatemachine statemachine) {
+		this.statemachine = statemachine;
+	}
+
+	public void raiseEvent1() {
+		statemachine.getOccuredEvents().add(EventEvent1);
+	}
+
+	public Event getEventEvent1() {
+		return EventEvent1;
+	}
+
+	public void raiseEvent2() {
+		statemachine.getOccuredEvents().add(EventEvent2);
+	}
+
+	public Event getEventEvent2() {
+		return EventEvent2;
+	}
+
+	public void raiseEvent3() {
+		statemachine.getOccuredEvents().add(EventEvent3);
+	}
+
+	public Event getEventEvent3() {
+		return EventEvent3;
+	}
+
+	public void raiseEvent4() {
+		statemachine.getOccuredEvents().add(EventEvent4);
+	}
+
+	public Event getEventEvent4() {
+		return EventEvent4;
+	}
+
+	public void raiseEvent5() {
+		statemachine.getOccuredEvents().add(EventEvent5);
+	}
+
+	public Event getEventEvent5() {
+		return EventEvent5;
+	}
+
+	public void raiseEvent6() {
+		statemachine.getOccuredEvents().add(EventEvent6);
+	}
+
+	public Event getEventEvent6() {
+		return EventEvent6;
+	}
+
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_parallelregions/Test_ParallelRegionsCycleBasedStatemachine.java

@@ -26,7 +26,7 @@ public class Test_ParallelRegionsCycleBasedStatemachine
 		State1, State2, State3, State4, State5, State6, State9, State7, State8,
 	};
 
-	private InterfaceDefaultImpl interfaceDefault;
+	private DefaultInterfaceImpl defaultInterface;
 
 	private final Set<State> activeStates = EnumSet.noneOf(State.class);
 
@@ -37,7 +37,7 @@ public class Test_ParallelRegionsCycleBasedStatemachine
 	public Test_ParallelRegionsCycleBasedStatemachine() {
 		occuredEvents = new ArrayList<Event>();
 		outEvents = new HashSet<Event>();
-		interfaceDefault = new InterfaceDefaultImpl(this);
+		defaultInterface = new DefaultInterfaceImpl(this);
 	}
 
 	protected Collection<Event> getOccuredEvents() {
@@ -60,8 +60,8 @@ public class Test_ParallelRegionsCycleBasedStatemachine
 		return EnumSet.copyOf(activeStates);
 	}
 
-	public InterfaceDefault getInterfaceDefault() {
-		return interfaceDefault;
+	public DefaultInterface getDefaultInterface() {
+		return defaultInterface;
 	}
 
 	public void enter() {
@@ -69,23 +69,23 @@ public class Test_ParallelRegionsCycleBasedStatemachine
 	}
 
 	private boolean conditionState1Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent1());
+		return occuredEvents.contains(defaultInterface.getEventEvent1());
 	}
 	private boolean conditionState3Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent2());
+		return occuredEvents.contains(defaultInterface.getEventEvent2());
 	}
 	private boolean conditionState5Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent3());
+		return occuredEvents.contains(defaultInterface.getEventEvent3());
 	}
 	private boolean conditionState6Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent4());
+		return occuredEvents.contains(defaultInterface.getEventEvent4());
 	}
 	private boolean conditionState7Tr0() {
-		return (occuredEvents.contains(interfaceDefault.getEventEvent5()) || occuredEvents
-				.contains(interfaceDefault.getEventEvent3()));
+		return (occuredEvents.contains(defaultInterface.getEventEvent5()) || occuredEvents
+				.contains(defaultInterface.getEventEvent3()));
 	}
 	private boolean conditionState8Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent6());
+		return occuredEvents.contains(defaultInterface.getEventEvent6());
 	}
 	private void actionsState1Tr0() {
 		exitSequenceState1();
@@ -158,42 +158,9 @@ public class Test_ParallelRegionsCycleBasedStatemachine
 	private void exitSequenceState1() {
 		activeStates.remove(State.State1);
 	}
-	private void exitSequenceState2() {
-		if (activeStates.contains(State.State3)) {
-			exitSequenceState3();
-
-		} else if (activeStates.contains(State.State5)) {
-			exitSequenceState5();
-
-		} else if (activeStates.contains(State.State6)) {
-			exitSequenceState6();
-
-		} else if (activeStates.contains(State.State9)) {
-			exitSequenceState9();
-
-		} else if (activeStates.contains(State.State7)) {
-			exitSequenceState7();
-
-		} else if (activeStates.contains(State.State8)) {
-			exitSequenceState8();
-
-		}
-	}
 	private void exitSequenceState3() {
 		activeStates.remove(State.State3);
 	}
-	private void exitSequenceState4() {
-		if (activeStates.contains(State.State5)) {
-			exitSequenceState5();
-
-		} else if (activeStates.contains(State.State6)) {
-			exitSequenceState6();
-
-		} else if (activeStates.contains(State.State9)) {
-			exitSequenceState9();
-
-		}
-	}
 	private void exitSequenceState5() {
 		activeStates.remove(State.State5);
 	}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_shallowhistory/InterfaceDefault.java

@@ -10,7 +10,7 @@
  */
 package org.yakindu.sct.runtime.java.test_shallowhistory;
 
-public interface InterfaceDefault {
+public interface DefaultInterface {
 
 	public void raiseEvent1();
 	public void raiseEvent2();

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_shallowhistory/InterfaceDefaultImpl.java

@@ -12,7 +12,7 @@ package org.yakindu.sct.runtime.java.test_shallowhistory;
 
 import org.yakindu.sct.runtime.java.Event;
 
-public class InterfaceDefaultImpl implements InterfaceDefault {
+public class DefaultInterfaceImpl implements DefaultInterface {
 
 	private final Event EventEvent1 = new Event("event1");
 	private final Event EventEvent2 = new Event("event2");
@@ -25,7 +25,7 @@ public class InterfaceDefaultImpl implements InterfaceDefault {
 
 	private Test_ShallowHistoryCycleBasedStatemachine statemachine;
 
-	public InterfaceDefaultImpl(
+	public DefaultInterfaceImpl(
 			Test_ShallowHistoryCycleBasedStatemachine statemachine) {
 		this.statemachine = statemachine;
 	}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_shallowhistory/Interface.java

@@ -0,0 +1,24 @@
+/**
+ * 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.runtime.java.test_shallowhistory;
+
+public interface Interface {
+
+	public void raiseEvent1();
+	public void raiseEvent2();
+	public void raiseEvent3();
+	public void raiseEvent4();
+	public void raiseEvent5();
+	public void raiseEvent6();
+	public void raiseEvent7();
+	public void raiseEvent8();
+
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_shallowhistory/InterfaceImpl.java

@@ -0,0 +1,96 @@
+/**
+ * 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.runtime.java.test_shallowhistory;
+
+import org.yakindu.sct.runtime.java.Event;
+
+public class InterfaceImpl implements Interface {
+
+	private final Event EventEvent1 = new Event("event1");
+	private final Event EventEvent2 = new Event("event2");
+	private final Event EventEvent3 = new Event("event3");
+	private final Event EventEvent4 = new Event("event4");
+	private final Event EventEvent5 = new Event("event5");
+	private final Event EventEvent6 = new Event("event6");
+	private final Event EventEvent7 = new Event("event7");
+	private final Event EventEvent8 = new Event("event8");
+
+	private Test_ShallowHistoryCycleBasedStatemachine statemachine;
+
+	public InterfaceImpl(Test_ShallowHistoryCycleBasedStatemachine statemachine) {
+		this.statemachine = statemachine;
+	}
+
+	public void raiseEvent1() {
+		statemachine.getOccuredEvents().add(EventEvent1);
+	}
+
+	public Event getEventEvent1() {
+		return EventEvent1;
+	}
+
+	public void raiseEvent2() {
+		statemachine.getOccuredEvents().add(EventEvent2);
+	}
+
+	public Event getEventEvent2() {
+		return EventEvent2;
+	}
+
+	public void raiseEvent3() {
+		statemachine.getOccuredEvents().add(EventEvent3);
+	}
+
+	public Event getEventEvent3() {
+		return EventEvent3;
+	}
+
+	public void raiseEvent4() {
+		statemachine.getOccuredEvents().add(EventEvent4);
+	}
+
+	public Event getEventEvent4() {
+		return EventEvent4;
+	}
+
+	public void raiseEvent5() {
+		statemachine.getOccuredEvents().add(EventEvent5);
+	}
+
+	public Event getEventEvent5() {
+		return EventEvent5;
+	}
+
+	public void raiseEvent6() {
+		statemachine.getOccuredEvents().add(EventEvent6);
+	}
+
+	public Event getEventEvent6() {
+		return EventEvent6;
+	}
+
+	public void raiseEvent7() {
+		statemachine.getOccuredEvents().add(EventEvent7);
+	}
+
+	public Event getEventEvent7() {
+		return EventEvent7;
+	}
+
+	public void raiseEvent8() {
+		statemachine.getOccuredEvents().add(EventEvent8);
+	}
+
+	public Event getEventEvent8() {
+		return EventEvent8;
+	}
+
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_shallowhistory/Test_ShallowHistoryCycleBasedStatemachine.java

@@ -24,7 +24,7 @@ public class Test_ShallowHistoryCycleBasedStatemachine implements IStatemachine
 		State1, State2, State3, State4, State6, State7, State8, State9, State5,
 	};
 
-	private InterfaceDefaultImpl interfaceDefault;
+	private DefaultInterfaceImpl defaultInterface;
 
 	private final Set<State> activeStates = EnumSet.noneOf(State.class);
 
@@ -35,7 +35,7 @@ public class Test_ShallowHistoryCycleBasedStatemachine implements IStatemachine
 	public Test_ShallowHistoryCycleBasedStatemachine() {
 		occuredEvents = new ArrayList<Event>();
 		outEvents = new HashSet<Event>();
-		interfaceDefault = new InterfaceDefaultImpl(this);
+		defaultInterface = new DefaultInterfaceImpl(this);
 	}
 
 	protected Collection<Event> getOccuredEvents() {
@@ -58,8 +58,8 @@ public class Test_ShallowHistoryCycleBasedStatemachine implements IStatemachine
 		return EnumSet.copyOf(activeStates);
 	}
 
-	public InterfaceDefault getInterfaceDefault() {
-		return interfaceDefault;
+	public DefaultInterface getDefaultInterface() {
+		return defaultInterface;
 	}
 
 	public void enter() {
@@ -67,28 +67,28 @@ public class Test_ShallowHistoryCycleBasedStatemachine implements IStatemachine
 	}
 
 	private boolean conditionState1Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent1());
+		return occuredEvents.contains(defaultInterface.getEventEvent1());
 	}
 	private boolean conditionState2Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent2());
+		return occuredEvents.contains(defaultInterface.getEventEvent2());
 	}
 	private boolean conditionState3Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent3());
+		return occuredEvents.contains(defaultInterface.getEventEvent3());
 	}
 	private boolean conditionState4Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent4());
+		return occuredEvents.contains(defaultInterface.getEventEvent4());
 	}
 	private boolean conditionState6Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent5());
+		return occuredEvents.contains(defaultInterface.getEventEvent5());
 	}
 	private boolean conditionState7Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent6());
+		return occuredEvents.contains(defaultInterface.getEventEvent6());
 	}
 	private boolean conditionState8Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent7());
+		return occuredEvents.contains(defaultInterface.getEventEvent7());
 	}
 	private boolean conditionState9Tr0() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent8());
+		return occuredEvents.contains(defaultInterface.getEventEvent8());
 	}
 	private void actionsState1Tr0() {
 		exitSequenceState1();

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_transition/InterfaceDefault.java

@@ -13,7 +13,7 @@ package org.yakindu.sct.runtime.java.test_transition;
 import org.yakindu.sct.runtime.java.Event;
 import org.yakindu.sct.runtime.java.INotificationSender;
 
-public interface InterfaceDefault extends INotificationSender {
+public interface DefaultInterface extends INotificationSender {
 
 	public void raiseEvent5();
 	public void raiseEvent5(boolean value);

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_transition/InterfaceDefaultImpl.java

@@ -15,9 +15,9 @@ import org.yakindu.sct.runtime.java.EventNotification;
 import org.yakindu.sct.runtime.java.NotificationSender;
 import org.yakindu.sct.runtime.java.ValuedEvent;
 
-public class InterfaceDefaultImpl extends NotificationSender
+public class DefaultInterfaceImpl extends NotificationSender
 		implements
-			InterfaceDefault {
+			DefaultInterface {
 
 	private final ValuedEvent<Boolean> EventEvent5 = new ValuedEvent<Boolean>(
 			"event5", false);
@@ -26,7 +26,7 @@ public class InterfaceDefaultImpl extends NotificationSender
 
 	private Test_TransitionCycleBasedStatemachine statemachine;
 
-	public InterfaceDefaultImpl(
+	public DefaultInterfaceImpl(
 			Test_TransitionCycleBasedStatemachine statemachine) {
 		this.statemachine = statemachine;
 	}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_transition/Interface.java

@@ -0,0 +1,29 @@
+/**
+ * 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.runtime.java.test_transition;
+
+import org.yakindu.sct.runtime.java.Event;
+import org.yakindu.sct.runtime.java.INotificationSender;
+
+public interface Interface extends INotificationSender {
+
+	public void raiseEvent5();
+	public void raiseEvent5(boolean value);
+	public void raiseEvent6();
+	public boolean isRaisedEvent7();
+
+	public Event getEventEvent7();
+
+	public int getVarI();
+	public void setVarI(int value);
+	public double getVarJ();
+	public void setVarJ(double value);
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_transition/InterfaceImpl.java

@@ -0,0 +1,84 @@
+/**
+ * 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.runtime.java.test_transition;
+
+import org.yakindu.sct.runtime.java.Event;
+import org.yakindu.sct.runtime.java.EventNotification;
+import org.yakindu.sct.runtime.java.NotificationSender;
+import org.yakindu.sct.runtime.java.ValuedEvent;
+
+public class InterfaceImpl extends NotificationSender implements Interface {
+
+	private final ValuedEvent<Boolean> EventEvent5 = new ValuedEvent<Boolean>(
+			"event5", false);
+	private final Event EventEvent6 = new Event("event6");
+	private final Event EventEvent7 = new Event("event7");
+
+	private Test_TransitionCycleBasedStatemachine statemachine;
+
+	public InterfaceImpl(Test_TransitionCycleBasedStatemachine statemachine) {
+		this.statemachine = statemachine;
+	}
+
+	public void raiseEvent5() {
+		statemachine.getOccuredEvents().add(EventEvent5);
+	}
+
+	public void raiseEvent5(boolean value) {
+		EventEvent5.setValue(value);
+		statemachine.getOccuredEvents().add(EventEvent5);
+	}
+
+	public ValuedEvent<Boolean> getEventEvent5() {
+		return EventEvent5;
+	}
+
+	public void raiseEvent6() {
+		statemachine.getOccuredEvents().add(EventEvent6);
+	}
+
+	public Event getEventEvent6() {
+		return EventEvent6;
+	}
+
+	public void raiseEvent7() {
+		statemachine.getOccuredEvents().add(EventEvent7);
+		statemachine.getOutEvents().add(EventEvent7);
+		notifyListeners(new EventNotification(EventEvent7));
+	}
+
+	public Event getEventEvent7() {
+		return EventEvent7;
+	}
+
+	public boolean isRaisedEvent7() {
+		return statemachine.getOutEvents().contains(EventEvent7);
+	}
+
+	private int varI;
+
+	public int getVarI() {
+		return varI;
+	}
+
+	public void setVarI(int value) {
+		varI = value;
+	}
+	private double varJ;
+
+	public double getVarJ() {
+		return varJ;
+	}
+
+	public void setVarJ(double value) {
+		varJ = value;
+	}
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src-gen/org/yakindu/sct/runtime/java/test_transition/Test_TransitionCycleBasedStatemachine.java

@@ -40,7 +40,7 @@ public class Test_TransitionCycleBasedStatemachine
 	};
 
 	private InterfaceAImpl interfaceA;
-	private InterfaceDefaultImpl interfaceDefault;
+	private DefaultInterfaceImpl defaultInterface;
 
 	private final Set<State> activeStates = EnumSet.noneOf(State.class);
 
@@ -56,7 +56,7 @@ public class Test_TransitionCycleBasedStatemachine
 		occuredEvents = new ArrayList<Event>();
 		outEvents = new HashSet<Event>();
 		interfaceA = new InterfaceAImpl(this);
-		interfaceDefault = new InterfaceDefaultImpl(this);
+		defaultInterface = new DefaultInterfaceImpl(this);
 	}
 
 	protected Collection<Event> getOccuredEvents() {
@@ -102,8 +102,8 @@ public class Test_TransitionCycleBasedStatemachine
 		return interfaceA;
 	}
 
-	public InterfaceDefault getInterfaceDefault() {
-		return interfaceDefault;
+	public DefaultInterface getDefaultInterface() {
+		return defaultInterface;
 	}
 
 	private void raiseEvent10() {
@@ -129,22 +129,22 @@ public class Test_TransitionCycleBasedStatemachine
 				.contains(interfaceA.getEventEvent2()));
 	}
 	private boolean conditionState1Tr1() {
-		return (interfaceDefault.getVarI() == 5);
+		return (defaultInterface.getVarI() == 5);
 	}
 	private boolean conditionState1Tr2() {
-		return (occuredEvents.contains(interfaceA.getEventEvent3()) && (interfaceDefault
+		return (occuredEvents.contains(interfaceA.getEventEvent3()) && (defaultInterface
 				.getVarJ() < 20));
 	}
 	private boolean conditionState1Tr3() {
 		return ((occuredEvents.contains(interfaceA.getEventEvent3()) || occuredEvents
-				.contains(interfaceA.getEventEvent4())) && (interfaceDefault
+				.contains(interfaceA.getEventEvent4())) && (defaultInterface
 				.getVarJ() > 30));
 	}
 	private boolean conditionState1Tr4() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent6());
+		return occuredEvents.contains(defaultInterface.getEventEvent6());
 	}
 	private boolean conditionState1Tr5() {
-		return occuredEvents.contains(interfaceDefault.getEventEvent7());
+		return occuredEvents.contains(defaultInterface.getEventEvent7());
 	}
 	private boolean conditionState1Tr6() {
 		return occuredEvents.contains(State1_time_event_0);
@@ -177,14 +177,14 @@ public class Test_TransitionCycleBasedStatemachine
 	}
 	private void actionsState1Tr4() {
 		exitSequenceState1();
-		interfaceDefault.setVarI(15);
+		defaultInterface.setVarI(15);
 
 		enterSequenceState2();
 
 	}
 	private void actionsState1Tr5() {
 		exitSequenceState1();
-		interfaceDefault.setVarJ((interfaceDefault.getVarI() * 9));
+		defaultInterface.setVarJ((defaultInterface.getVarI() * 9));
 
 		enterSequenceState2();
 
@@ -228,9 +228,6 @@ public class Test_TransitionCycleBasedStatemachine
 		activeStates.remove(State.State1);
 		exitActionState1();
 	}
-	private void exitSequenceState2() {
-		activeStates.remove(State.State2);
-	}
 	private void reactState1() {
 		if (conditionState1Tr0()) {
 			actionsState1Tr0();

test-plugins/org.yakindu.sct.generator.java.runtime.test/src/org/yakindu/sct/generator/java/runtime/test/TestExpressionCycleBasedStatemachine.java

@@ -25,56 +25,56 @@ public class TestExpressionCycleBasedStatemachine {
 	@Test
 	public void testCycles() {
 		assertEquals("Var3 value not set correct: ", 2405.6, statemachine
-				.getInterfaceDefault().getVarVar3(),Math.pow(10, -8));
+				.getDefaultInterface().getVarVar3(),Math.pow(10, -8));
 		
-		statemachine.getInterfaceDefault().raiseEvent1();
+		statemachine.getDefaultInterface().raiseEvent1();
 		statemachine.runCycle();
 		assertEquals("Other.Var1 value not set correct: ", false, statemachine
 				.getInterfaceOther().getVarVar1());
 		assertEquals("Default.Var2 value not set correct: ", 1, statemachine
-				.getInterfaceDefault().getVarVar2());
+				.getDefaultInterface().getVarVar2());
 		assertEquals("Default.Var4 value not set correct: ", 22.3, statemachine
-				.getInterfaceDefault().getVarVar4(),Math.pow(10, -8));
+				.getDefaultInterface().getVarVar4(),Math.pow(10, -8));
 		assertEquals("Other.Var3 value not set correct: ", 481.12, statemachine
-				.getInterfaceDefault().getVarVar3(),Math.pow(10, -8));
+				.getDefaultInterface().getVarVar3(),Math.pow(10, -8));
 		assertEquals("Default.Var1 value not set correct: ", 7, statemachine
-				.getInterfaceDefault().getVarVar1());
+				.getDefaultInterface().getVarVar1());
 		
 		statemachine.runCycle();
 		assertEquals("Other.Var1 value not set correct: ", false, statemachine
 				.getInterfaceOther().getVarVar1());
 		assertEquals("Default.Var2 value not set correct: ", 1, statemachine
-				.getInterfaceDefault().getVarVar2());
+				.getDefaultInterface().getVarVar2());
 		assertEquals("Default.Var4 value not set correct: ", 22.3, statemachine
-				.getInterfaceDefault().getVarVar4(),Math.pow(10, -8));
+				.getDefaultInterface().getVarVar4(),Math.pow(10, -8));
 		assertEquals("Other.Var3 value not set correct: ", 481.12, statemachine
-				.getInterfaceDefault().getVarVar3(),Math.pow(10, -8));
+				.getDefaultInterface().getVarVar3(),Math.pow(10, -8));
 		assertEquals("Default.Var1 value not set correct: ", 8, statemachine
-				.getInterfaceDefault().getVarVar1());
+				.getDefaultInterface().getVarVar1());
 		
 		statemachine.runCycle();
 		assertEquals("Other.Var1 value not set correct: ", false, statemachine
 				.getInterfaceOther().getVarVar1());
 		assertEquals("Default.Var2 value not set correct: ", 1, statemachine
-				.getInterfaceDefault().getVarVar2());
+				.getDefaultInterface().getVarVar2());
 		assertEquals("Default.Var4 value not set correct: ", 22.3, statemachine
-				.getInterfaceDefault().getVarVar4(),Math.pow(10, -8));
+				.getDefaultInterface().getVarVar4(),Math.pow(10, -8));
 		assertEquals("Other.Var3 value not set correct: ", 481.12, statemachine
-				.getInterfaceDefault().getVarVar3(),Math.pow(10, -8));
+				.getDefaultInterface().getVarVar3(),Math.pow(10, -8));
 		assertEquals("Default.Var1 value not set correct: ", 9, statemachine
-				.getInterfaceDefault().getVarVar1());
+				.getDefaultInterface().getVarVar1());
 		
-		statemachine.getInterfaceDefault().raiseEvent1();
+		statemachine.getDefaultInterface().raiseEvent1();
 		statemachine.runCycle();
 		assertEquals("Default.Var5 value not set correct: ", true, statemachine
-				.getInterfaceDefault().getVarVar5());
+				.getDefaultInterface().getVarVar5());
 		assertEquals("Other.Var3 value not set correct: ", 962.24, statemachine
-				.getInterfaceDefault().getVarVar3(),Math.pow(10, -8));
+				.getDefaultInterface().getVarVar3(),Math.pow(10, -8));
 		
-		statemachine.getInterfaceDefault().raiseEvent1();
+		statemachine.getDefaultInterface().raiseEvent1();
 		statemachine.runCycle();
 		assertEquals("Other.Var3 value not set correct: ", 962.24, statemachine
-				.getInterfaceDefault().getVarVar3(),Math.pow(10, -8));
+				.getDefaultInterface().getVarVar3(),Math.pow(10, -8));
 		
 	}
 }

test-plugins/org.yakindu.sct.generator.java.runtime.test/src/org/yakindu/sct/generator/java/runtime/test/TestHierarchyCycleBasedStatemachine.java

@@ -0,0 +1,37 @@
+/**
+ * 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:
+ * 	@author markus muehlbrandt - initial API and implementation
+ * 
+ */
+package org.yakindu.sct.generator.java.runtime.test;
+
+import org.junit.After;
+import org.junit.Before;
+import org.yakindu.sct.runtime.java.test_hierarchy.Test_HierarchyCycleBasedStatemachine;
+
+/**
+ * Testcases for 'Test_LocalActions' cycle based statemachine.
+ * 
+ * @author muehlbrandt
+ * 
+ */
+public class TestHierarchyCycleBasedStatemachine {
+
+	private Test_HierarchyCycleBasedStatemachine statemachine;
+
+	@Before
+	public void setUp() {
+		statemachine = new Test_HierarchyCycleBasedStatemachine();
+		statemachine.enter();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+}

test-plugins/org.yakindu.sct.generator.java.runtime.test/src/org/yakindu/sct/generator/java/runtime/test/TestInterfaceTestCycleBasedStatemachine.java

@@ -46,15 +46,15 @@ public class TestInterfaceTestCycleBasedStatemachine {
 	public void testExceptionHandling() {
 		// Value of Event 2 should not be set to null
 		try {
-			statemachine.getInterfaceDefault().getEventEvent2().setValue(null);
-			fail("statemachine.getInterfaceDefault().getEventEvent2().setValue(null) should throw IllegalArgumentException");
+			statemachine.getDefaultInterface().getEventEvent2().setValue(null);
+			fail("statemachine.getDefaultInterface().getEventEvent2().setValue(null) should throw IllegalArgumentException");
 		} catch (IllegalArgumentException exception) {
 		}
 
 		// Value of Event 6 should not be set to null
 		try {
 			statemachine.getInterfaceThird().getEventEvent6().setValue(null);
-			fail("statemachine.getInterfaceDefault().getEventEvent2().setValue(null) should throw IllegalArgumentException");
+			fail("statemachine.getDefaultInterface().getEventEvent2().setValue(null) should throw IllegalArgumentException");
 		} catch (IllegalArgumentException exception) {
 		}
 	}
@@ -62,10 +62,10 @@ public class TestInterfaceTestCycleBasedStatemachine {
 	@Test
 	public void testStatemachineEntry() {
 		assertEquals("InterfaceDefault.Var2 is not correct initialized:", 2.3,
-				statemachine.getInterfaceDefault().getVarVar2(),
+				statemachine.getDefaultInterface().getVarVar2(),
 				Math.pow(10, -8));
 		assertEquals("InterfaceDefault.Var3 is not correct initialized:", 1,
-				statemachine.getInterfaceDefault().getVarVar3());
+				statemachine.getDefaultInterface().getVarVar3());
 		assertTrue("Statemachine isn't in State: " + State.State1.name() + ".",
 				statemachine.getActiveStates().contains(State.State1));
 		assertEquals("More than one state is active.", 1, statemachine
@@ -74,7 +74,7 @@ public class TestInterfaceTestCycleBasedStatemachine {
 
 	@Test
 	public void testStatemachineRunCycle_1() {
-		statemachine.getInterfaceDefault().raiseEvent1();
+		statemachine.getDefaultInterface().raiseEvent1();
 		statemachine.runCycle();
 		// Test if state is changed to State2
 		assertTrue("Statemachine isn't in State: " + State.State2.name() + ".",
@@ -83,13 +83,13 @@ public class TestInterfaceTestCycleBasedStatemachine {
 		assertEquals("More than one state is active.", 1, statemachine
 				.getActiveStates().size());
 		// Test if event2 is raised (happens in entry of State2
-		assertTrue("Event not raised: ", statemachine.getInterfaceDefault()
+		assertTrue("Event not raised: ", statemachine.getDefaultInterface()
 				.isRaisedEvent2());
 		// Test if event2 value is set to 22 (happens in entry of State2
 		assertEquals("Event 2 value not set correct: ", 22, statemachine
-				.getInterfaceDefault().getEventEvent2().getValue().intValue());
+				.getDefaultInterface().getEventEvent2().getValue().intValue());
 
-		statemachine.getInterfaceDefault().raiseEvent1();
+		statemachine.getDefaultInterface().raiseEvent1();
 		statemachine.runCycle();
 		// Test if statemachine is back in State 1
 		assertTrue("Statemachine isn't in State: " + State.State1.name() + ".",
@@ -99,13 +99,13 @@ public class TestInterfaceTestCycleBasedStatemachine {
 				.getActiveStates().size());
 		// Event 2 shouldn't be raised anymore
 		assertFalse("Event is still raised: ", statemachine
-				.getInterfaceDefault().isRaisedEvent2());
+				.getDefaultInterface().isRaisedEvent2());
 	}
 
 	@Test
 	public void testStatemachineRunCycle_2() {
-		statemachine.getInterfaceDefault().setVarVar2(-12.6);
-		statemachine.getInterfaceDefault().raiseEvent1();
+		statemachine.getDefaultInterface().setVarVar2(-12.6);
+		statemachine.getDefaultInterface().raiseEvent1();
 		statemachine.runCycle();
 		// Test if statemachine is still in State 1
 		assertTrue("Statemachine isn't in State: " + State.State1.name() + ".",
@@ -115,13 +115,13 @@ public class TestInterfaceTestCycleBasedStatemachine {
 				.getActiveStates().size());
 		// Event 2 shouldn't be raised
 		assertFalse("Event is still raised: ", statemachine
-				.getInterfaceDefault().isRaisedEvent2());
+				.getDefaultInterface().isRaisedEvent2());
 		// Event 2 value should not be set to 22
 		assertTrue("Event value is set to 22: ", statemachine
-				.getInterfaceDefault().getEventEvent2().getValue() != 22);
+				.getDefaultInterface().getEventEvent2().getValue() != 22);
 
-		statemachine.getInterfaceDefault().raiseEvent1();
-		statemachine.getInterfaceDefault().setVarVar2(213.55);
+		statemachine.getDefaultInterface().raiseEvent1();
+		statemachine.getDefaultInterface().setVarVar2(213.55);
 		statemachine.runCycle();
 		// Test if state is changed to State2
 		assertTrue("Statemachine isn't in State: " + State.State2.name() + ".",
@@ -130,11 +130,11 @@ public class TestInterfaceTestCycleBasedStatemachine {
 		assertEquals("More than one state is active.", 1, statemachine
 				.getActiveStates().size());
 		// Test if event2 is raised (happens in entry of State2
-		assertTrue("Event not raised: ", statemachine.getInterfaceDefault()
+		assertTrue("Event not raised: ", statemachine.getDefaultInterface()
 				.isRaisedEvent2());
 		// Test if event2 value is set to 22 (happens in entry of State2
 		assertEquals("Event 2 value not set correct: ", 22, statemachine
-				.getInterfaceDefault().getEventEvent2().getValue().intValue());
+				.getDefaultInterface().getEventEvent2().getValue().intValue());
 	}
 
 	@Test
@@ -166,7 +166,7 @@ public class TestInterfaceTestCycleBasedStatemachine {
 
 	@Test
 	public void testStatemachineRunCycle_4() {
-		statemachine.getInterfaceDefault().setVarVar3(2);
+		statemachine.getDefaultInterface().setVarVar3(2);
 		statemachine.getInterfaceOther().raiseEvent3();
 		statemachine.runCycle();
 		// Test if state is changed to State1
@@ -180,7 +180,7 @@ public class TestInterfaceTestCycleBasedStatemachine {
 				.isRaisedEvent4());
 
 		statemachine.getInterfaceOther().raiseEvent3();
-		statemachine.getInterfaceDefault().setVarVar3(1);
+		statemachine.getDefaultInterface().setVarVar3(1);
 		statemachine.runCycle();
 		// Test if state is changed to State3
 		assertTrue("Statemachine isn't in State: " + State.State3.name() + ".",
@@ -195,7 +195,7 @@ public class TestInterfaceTestCycleBasedStatemachine {
 
 	@Test
 	public void testStatemachineRunCycle_5() {
-		statemachine.getInterfaceDefault().setVarVar1(true);
+		statemachine.getDefaultInterface().setVarVar1(true);
 		statemachine.getInterfaceThird().raiseEvent5();
 		statemachine.runCycle();
 		// Test if state is changed to State4

test-plugins/org.yakindu.sct.generator.java.runtime.test/src/org/yakindu/sct/generator/java/runtime/test/TestLocalActionsCycleBasedStatemachine.java

@@ -71,7 +71,7 @@ public class TestLocalActionsCycleBasedStatemachine {
 		assertEquals("More than one state is active.", 1, statemachine
 				.getActiveStates().size());
 		assertEquals("Variable i not set to 1", 1, statemachine
-				.getInterfaceDefault().getVarI());
+				.getDefaultInterface().getVarI());
 	}
 
 	@Test
@@ -79,24 +79,24 @@ public class TestLocalActionsCycleBasedStatemachine {
 		final long time = System.currentTimeMillis();
 
 		assertEquals("Error in local reaction \"Entry / i=1;\" of State1", 1,
-				statemachine.getInterfaceDefault().getVarI());
+				statemachine.getDefaultInterface().getVarI());
 
 		statemachine.runCycle();
 		assertEquals("Error in local reaction \"onCycle / i=2;\" of State1", 2,
-				statemachine.getInterfaceDefault().getVarI());
+				statemachine.getDefaultInterface().getVarI());
 
-		statemachine.getInterfaceDefault().raiseEvent2();
+		statemachine.getDefaultInterface().raiseEvent2();
 		statemachine.runCycle();
 		assertEquals("Error in local reaction \"Event2 / i=3;\" of State1", 3,
-				statemachine.getInterfaceDefault().getVarI());
+				statemachine.getDefaultInterface().getVarI());
 
 		// Check timer behavior
-		while (statemachine.getInterfaceDefault().getVarC() < 10) {
+		while (statemachine.getDefaultInterface().getVarC() < 10) {
 			statemachine.runCycle();
 			Thread.sleep(junitSleepTime);
 		}
 		final long time2 = System.currentTimeMillis() - time;
-		final long expectedTime = statemachine.getInterfaceDefault().getVarC() * 100;
+		final long expectedTime = statemachine.getDefaultInterface().getVarC() * 100;
 		final long delta = time2 - expectedTime;
 		assertTrue("Timer threshold overflow in State 1. Delta is " + delta
 				+ " ms. Threshold is: " + timerThreshold + " ms.",
@@ -106,25 +106,25 @@ public class TestLocalActionsCycleBasedStatemachine {
 	@Test
 	public void testState2LocalReaction() throws InterruptedException {
 		// Switch to State2;
-		statemachine.getInterfaceDefault().raiseEvent1();
+		statemachine.getDefaultInterface().raiseEvent1();
 		statemachine.runCycle();
 		final long time = System.currentTimeMillis();
 
 		assertEquals("Error in local reaction \"exit / i=0;\" of State1", 0,
-				statemachine.getInterfaceDefault().getVarI());
+				statemachine.getDefaultInterface().getVarI());
 
 		assertEquals("Error in local reaction \"entry / j=0;\" of State2", 1,
-				statemachine.getInterfaceDefault().getVarJ());
+				statemachine.getDefaultInterface().getVarJ());
 
 		// Check local reaction for Event2
-		statemachine.getInterfaceDefault().raiseEvent2();
+		statemachine.getDefaultInterface().raiseEvent2();
 		statemachine.runCycle();
 		assertEquals(
 				"Error in local reaction \"Event2, Event4 / j=2;\" of State2",
-				2, statemachine.getInterfaceDefault().getVarJ());
+				2, statemachine.getDefaultInterface().getVarJ());
 
 		// Check timer behavior
-		while (statemachine.getInterfaceDefault().getVarJ() != 3) {
+		while (statemachine.getDefaultInterface().getVarJ() != 3) {
 			statemachine.runCycle();
 			Thread.sleep(junitSleepTime);
 		}
@@ -137,16 +137,16 @@ public class TestLocalActionsCycleBasedStatemachine {
 				time2 <= expectedTime + timerThreshold);
 
 		// Check local reaction for Event4
-		statemachine.getInterfaceDefault().raiseEvent4();
+		statemachine.getDefaultInterface().raiseEvent4();
 		statemachine.runCycle();
 		assertEquals(
 				"Error in local reaction \"Event2, Event4 / j=2;\" of State2",
-				2, statemachine.getInterfaceDefault().getVarJ());
+				2, statemachine.getDefaultInterface().getVarJ());
 
 		// Check local reaction for exit
-		statemachine.getInterfaceDefault().raiseEvent3();
+		statemachine.getDefaultInterface().raiseEvent3();
 		statemachine.runCycle();
 		assertEquals("Error in local reaction \"exit / j=0;\" of State2", 0,
-				statemachine.getInterfaceDefault().getVarJ());
+				statemachine.getDefaultInterface().getVarJ());
 	}
 }