added new tests for issue #355

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

@@ -23,10 +23,33 @@ GeneratorModel for yakindu::java {
 			inlineEnterRegion = false
 			inlineExitRegion = false
 			inlineEntries = false
+		}		
+	}
+
+
+	statechart expressions.TriggerExpressionPrecedence  {
+		feature Outlet {
+			targetProject = "org.yakindu.sct.generator.java.test"
+			targetFolder = "src-gen"
+		}
+
+
+		feature GeneralFeatures {
+			TimerService = true
+			RuntimeService = true
 		}
 		
-		
-		
+		feature FunctionInlining {
+			inlineReactions = false
+			inlineEntryActions = false
+			inlineExitActions = false
+			inlineEnterSequences = false
+			inlineExitSequences = false
+			inlineChoices = false
+			inlineEnterRegion = false
+			inlineExitRegion = false
+			inlineEntries = false
+		}		
 	}
 	
 	statechart AlwaysOncycle {

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

@@ -8,13 +8,6 @@ GeneratorModel for sctunit::java {
 		}			
 	}
 
-	test EntryReactionAction{
-		
-		feature Outlet{ 
-			targetProject = "org.yakindu.sct.generator.java.test" 
-			targetFolder = "test-gen"			
-		}			
-	}
 	
 	test AlwaysOncycle{
 		
@@ -152,6 +145,14 @@ GeneratorModel for sctunit::java {
 		}			
 	}
 	
+	test EntryReactionAction{
+		
+		feature Outlet{ 
+			targetProject = "org.yakindu.sct.generator.java.test" 
+			targetFolder = "test-gen"			
+		}			
+	}
+	
 	test ExitOnSelfTransition{
 		
 		feature Outlet{ 
@@ -469,6 +470,14 @@ GeneratorModel for sctunit::java {
 		}			
 	}
 
+	test TriggerExpressionPrecedence {
+		
+		feature Outlet{ 
+			targetProject = "org.yakindu.sct.generator.java.test" 
+			targetFolder = "test-gen"			
+		}			
+	}
+
 
 	test ValuedEvents{
 		

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/entryreactionaction/EntryReactionActionStatemachine.java

@@ -105,7 +105,7 @@ public class EntryReactionActionStatemachine implements IEntryReactionActionStat
 	public void enter() {
 		if (!initialized)
 			throw new IllegalStateException(
-					"The statemachine needs to be initialized first by calling the init() function.");
+					"The state machine needs to be initialized first by calling the init() function.");
 
 		enterSequence_EntryReactionAction_r2_default();
 
@@ -484,7 +484,7 @@ public class EntryReactionActionStatemachine implements IEntryReactionActionStat
 	public void runCycle() {
 		if (!initialized)
 			throw new IllegalStateException(
-					"The statemachine needs to be initialized first by calling the init() function.");
+					"The state machine needs to be initialized first by calling the init() function.");
 
 		clearOutEvents();
 

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/triggerexpressionprecedence/ITriggerExpressionPrecedenceStatemachine.java

@@ -0,0 +1,21 @@
+package org.yakindu.scr.triggerexpressionprecedence;
+import org.yakindu.scr.IStatemachine;
+
+public interface ITriggerExpressionPrecedenceStatemachine extends IStatemachine {
+	public interface SCInterface {
+		public void raiseE1();
+		public void raiseE2();
+		public boolean getC1();
+		public void setC1(boolean value);
+		public boolean getC2();
+		public void setC2(boolean value);
+		public boolean getE1_transition();
+		public void setE1_transition(boolean value);
+		public boolean getE2_transition();
+		public void setE2_transition(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/triggerexpressionprecedence/TriggerExpressionPrecedenceStatemachine.java

@@ -0,0 +1,285 @@
+package org.yakindu.scr.triggerexpressionprecedence;
+
+public class TriggerExpressionPrecedenceStatemachine implements ITriggerExpressionPrecedenceStatemachine {
+
+	protected class SCInterfaceImpl implements SCInterface {
+
+		private boolean e1;
+
+		public void raiseE1() {
+			e1 = true;
+		}
+
+		private boolean e2;
+
+		public void raiseE2() {
+			e2 = true;
+		}
+
+		private boolean c1;
+
+		public boolean getC1() {
+			return c1;
+		}
+
+		public void setC1(boolean value) {
+			this.c1 = value;
+		}
+
+		private boolean c2;
+
+		public boolean getC2() {
+			return c2;
+		}
+
+		public void setC2(boolean value) {
+			this.c2 = value;
+		}
+
+		private boolean e1_transition;
+
+		public boolean getE1_transition() {
+			return e1_transition;
+		}
+
+		public void setE1_transition(boolean value) {
+			this.e1_transition = value;
+		}
+
+		private boolean e2_transition;
+
+		public boolean getE2_transition() {
+			return e2_transition;
+		}
+
+		public void setE2_transition(boolean value) {
+			this.e2_transition = value;
+		}
+
+		protected void clearEvents() {
+			e1 = false;
+			e2 = false;
+		}
+
+	}
+
+	protected SCInterfaceImpl sCInterface;
+
+	private boolean initialized = false;
+
+	public enum State {
+		triggerExpressionPrecedence_main_region_A, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public TriggerExpressionPrecedenceStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		this.initialized = true;
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.setC1(false);
+
+		sCInterface.setC2(false);
+
+		sCInterface.setE1_transition(false);
+
+		sCInterface.setE2_transition(false);
+	}
+
+	public void enter() {
+		if (!initialized)
+			throw new IllegalStateException(
+					"The state machine needs to be initialized first by calling the init() function.");
+
+		enterSequence_TriggerExpressionPrecedence_main_region_default();
+	}
+
+	public void exit() {
+		exitSequence_TriggerExpressionPrecedence_main_region();
+	}
+
+	/**
+	 * @see IStatemachine#isActive()
+	 */
+	public boolean isActive() {
+
+		return stateVector[0] != State.$NullState$;
+	}
+
+	/** 
+	* Always returns 'false' since this state machine can never become final.
+	*
+	 * @see IStatemachine#isFinal() 
+	 */
+	public boolean isFinal() {
+		return false;
+	}
+
+	/**
+	* This method resets the incoming events (time events included).
+	*/
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	* This method resets the outgoing events.
+	*/
+	protected void clearOutEvents() {
+	}
+
+	/**
+	* Returns true if the given state is currently active otherwise false.
+	*/
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case triggerExpressionPrecedence_main_region_A :
+				return stateVector[0] == State.triggerExpressionPrecedence_main_region_A;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE1() {
+		sCInterface.raiseE1();
+	}
+	public void raiseE2() {
+		sCInterface.raiseE2();
+	}
+
+	public boolean getC1() {
+		return sCInterface.getC1();
+	}
+
+	public void setC1(boolean value) {
+		sCInterface.setC1(value);
+	}
+	public boolean getC2() {
+		return sCInterface.getC2();
+	}
+
+	public void setC2(boolean value) {
+		sCInterface.setC2(value);
+	}
+	public boolean getE1_transition() {
+		return sCInterface.getE1_transition();
+	}
+
+	public void setE1_transition(boolean value) {
+		sCInterface.setE1_transition(value);
+	}
+	public boolean getE2_transition() {
+		return sCInterface.getE2_transition();
+	}
+
+	public void setE2_transition(boolean value) {
+		sCInterface.setE2_transition(value);
+	}
+
+	private boolean check_TriggerExpressionPrecedence_main_region_A_tr0_tr0() {
+		return (sCInterface.e1) && sCInterface.getC1() || sCInterface.getC2();
+	}
+
+	private boolean check_TriggerExpressionPrecedence_main_region_A_tr1_tr1() {
+		return sCInterface.e2;
+	}
+
+	private void effect_TriggerExpressionPrecedence_main_region_A_tr0() {
+		exitSequence_TriggerExpressionPrecedence_main_region_A();
+
+		sCInterface.setE1_transition(true);
+
+		enterSequence_TriggerExpressionPrecedence_main_region_A_default();
+	}
+
+	private void effect_TriggerExpressionPrecedence_main_region_A_tr1() {
+		exitSequence_TriggerExpressionPrecedence_main_region_A();
+
+		sCInterface.setE2_transition(true);
+
+		enterSequence_TriggerExpressionPrecedence_main_region_A_default();
+	}
+
+	/* 'default' enter sequence for state A */
+	private void enterSequence_TriggerExpressionPrecedence_main_region_A_default() {
+		nextStateIndex = 0;
+		stateVector[0] = State.triggerExpressionPrecedence_main_region_A;
+	}
+
+	/* 'default' enter sequence for region main region */
+	private void enterSequence_TriggerExpressionPrecedence_main_region_default() {
+		react_TriggerExpressionPrecedence_main_region__entry_Default();
+	}
+
+	/* Default exit sequence for state A */
+	private void exitSequence_TriggerExpressionPrecedence_main_region_A() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+	}
+
+	/* Default exit sequence for region main region */
+	private void exitSequence_TriggerExpressionPrecedence_main_region() {
+		switch (stateVector[0]) {
+			case triggerExpressionPrecedence_main_region_A :
+				exitSequence_TriggerExpressionPrecedence_main_region_A();
+				break;
+
+			default :
+				break;
+		}
+	}
+
+	/* The reactions of state A. */
+	private void react_TriggerExpressionPrecedence_main_region_A() {
+		if (check_TriggerExpressionPrecedence_main_region_A_tr0_tr0()) {
+			effect_TriggerExpressionPrecedence_main_region_A_tr0();
+		} else {
+			if (check_TriggerExpressionPrecedence_main_region_A_tr1_tr1()) {
+				effect_TriggerExpressionPrecedence_main_region_A_tr1();
+			}
+		}
+	}
+
+	/* Default react sequence for initial entry  */
+	private void react_TriggerExpressionPrecedence_main_region__entry_Default() {
+		enterSequence_TriggerExpressionPrecedence_main_region_A_default();
+	}
+
+	public void runCycle() {
+		if (!initialized)
+			throw new IllegalStateException(
+					"The state machine needs to be initialized first by calling the init() function.");
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case triggerExpressionPrecedence_main_region_A :
+					react_TriggerExpressionPrecedence_main_region_A();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

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

@@ -28,6 +28,7 @@ import org.junit.runners.Suite.SuiteClasses;
 		ShallowHistoryWithDeepEntryTest.class, SimpleEventTest.class, SimpleHierachyTest.class,
 		StatechartActiveTest.class, StatechartLocalReactionsTest.class, StateIsActiveTest.class, StaticChoiceTest.class,
 		STextKeywordsInStatesAndRegionsTest.class, StringExpressionsTest.class, SyncForkTest.class, SyncJoinTest.class,
-		TransitionWithoutConditionTest.class, TriggerGuardExpressionsTest.class, ValuedEventsTest.class})
+		TransitionWithoutConditionTest.class, TriggerGuardExpressionsTest.class, TriggerExpressionPrecedenceTest.class,
+		ValuedEventsTest.class})
 public class AllTestsTest {
 }

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

@@ -0,0 +1,71 @@
+/**
+* Copyright (c) 2016 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+
+package org.yakindu.sct.generator.java.test;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceStatemachine;
+import org.yakindu.scr.triggerexpressionprecedence.TriggerExpressionPrecedenceStatemachine.State;
+/**
+ *  Unit TestCase for TriggerExpressionPrecedence
+ */
+@SuppressWarnings("all")
+public class TriggerExpressionPrecedenceTest {
+
+	private TriggerExpressionPrecedenceStatemachine statemachine;
+
+	@Before
+	public void setUp() {
+		statemachine = new TriggerExpressionPrecedenceStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+
+	@Test
+	public void testunsatisfiedTriggerAndFGuardFalseOrFalse() {
+		statemachine.enter();
+		statemachine.setC1(false);
+		statemachine.setC2(false);
+		statemachine.runCycle();
+		assertTrue(!statemachine.getE1_transition());
+	}
+	@Test
+	public void testunsatisfiedTriggerAndFGuardTrueOrFalse() {
+		statemachine.enter();
+		statemachine.setC1(true);
+		statemachine.setC2(false);
+		statemachine.runCycle();
+		assertTrue(!statemachine.getE1_transition());
+	}
+	@Test
+	public void testunsatisfiedTriggerAndFGuardFalseOrTrue() {
+		statemachine.enter();
+		statemachine.setC1(false);
+		statemachine.setC2(true);
+		statemachine.runCycle();
+		assertTrue(!statemachine.getE1_transition());
+	}
+	@Test
+	public void testunsatisfiedTriggerAndFGuardtrueOrTrue() {
+		statemachine.enter();
+		statemachine.setC1(true);
+		statemachine.setC2(true);
+		statemachine.runCycle();
+		assertTrue(!statemachine.getE1_transition());
+	}
+}