#924: Using original type in type system access to generate proper type names for type aliases.

plugins/org.yakindu.sct.generator.c/src/org/yakindu/sct/generator/c/types/CTypeSystemAccess.xtend

@@ -25,13 +25,14 @@ class CTypeSystemAccess implements ICodegenTypeSystemAccess {
 	@Inject
 	extension ITypeSystem ts
 
-	override getTargetLanguageName(Type type) {
-		switch (type) {
-			case type == null || ts.isSame(type, getType(VOID)) : 'void'
-			case ts.isSame(type, getType(INTEGER)): 'sc_integer'
-			case ts.isSame(type, getType(REAL)): 'sc_real'
-			case ts.isSame(type, getType(BOOLEAN)): 'sc_boolean'
-			case ts.isSame(type, getType(STRING)): 'sc_string'
+	override getTargetLanguageName(Type type) {
+		val originialType = type?.originType
+		switch (originialType) {
+			case originialType == null || ts.isSame(originialType, getType(VOID)) : 'void'
+			case ts.isSame(originialType, getType(INTEGER)): 'sc_integer'
+			case ts.isSame(originialType, getType(REAL)): 'sc_real'
+			case ts.isSame(originialType, getType(BOOLEAN)): 'sc_boolean'
+			case ts.isSame(originialType, getType(STRING)): 'sc_string'
 			default: throw new IllegalArgumentException("Target language name could not be inferred for type " + type)
 		}
 	}

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/types/JavaTypeSystemAccess.xtend

@@ -25,13 +25,14 @@ class JavaTypeSystemAccess implements ICodegenTypeSystemAccess {
 	@Inject
 	private extension ITypeSystem ts
 
-	override String getTargetLanguageName(Type type) {
-		switch (type) {
-			case type == null || ts.isSame(type, getType(VOID)) : 'void'
-			case ts.isSame(type, getType(REAL)): "double"
-			case ts.isSame(type, getType(INTEGER)): "long"
-			case ts.isSame(type, getType(BOOLEAN)): "boolean"
-			case ts.isSame(type, getType(STRING)): "String"
+	override String getTargetLanguageName(Type type) {
+		val originalType = type?.originType
+		switch (originalType) {
+			case originalType == null || ts.isSame(originalType, getType(VOID)) : 'void'
+			case ts.isSame(originalType, getType(REAL)): "double"
+			case ts.isSame(originalType, getType(INTEGER)): "long"
+			case ts.isSame(originalType, getType(BOOLEAN)): "boolean"
+			case ts.isSame(originalType, getType(STRING)): "String"
 			default: "//" + this
 		};
 	}

test-plugins/org.yakindu.sct.generator.c.test/gtests/TypeAlias/TypeAlias.cc

@@ -0,0 +1,31 @@
+/**
+* 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
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "TypeAlias.h"
+
+TypeAlias handle;
+
+TEST(StatemachineTest, TypeAliasTest) {
+	typeAlias_init(&handle);
+	typeAlias_enter(&handle);
+	EXPECT_TRUE(typeAlias_isStateActive(&handle, TypeAlias_main_region_Start));
+	EXPECT_TRUE(typeAliasIface_get_myVar(&handle) == 1l);
+	typeAlias_runCycle(&handle);
+	EXPECT_TRUE(typeAlias_isStateActive(&handle, TypeAlias_main_region_Mid));
+	EXPECT_TRUE(typeAliasIface_get_myString(&handle) == "TypeSystem");
+	typeAlias_runCycle(&handle);
+	EXPECT_TRUE(typeAlias_isStateActive(&handle, TypeAlias_main_region_Mid2));
+	typeAliasIface_raise_myEvent(&handle);
+	typeAlias_runCycle(&handle);
+	EXPECT_TRUE(typeAlias_isStateActive(&handle, TypeAlias_main_region_End));
+}
+

test-plugins/org.yakindu.sct.generator.c.test/gtests/TypeAlias/TypeAlias.sgen

@@ -0,0 +1,19 @@
+GeneratorModel for yakindu::c {
+	statechart TypeAlias {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "TypeAlias"
+		}
+		feature FunctionInlining {
+			inlineReactions = false
+			inlineEntryActions = false
+			inlineEnterSequences = false 
+			inlineExitActions = false
+			inlineExitSequences = false
+			inlineChoices = false
+			inlineEntries = false
+			inlineEnterRegion = false
+			inlineExitRegion = false
+		}
+	}
+}

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

@@ -1400,4 +1400,28 @@ GeneratorModel for sctunit::c {
 			inlineEntries = false
 		}
 	}
+	
+	test TypeAlias {
+
+		feature Outlet {
+			targetProject = "org.yakindu.sct.generator.c.test"
+			targetFolder = "test-gen"
+		}
+
+		feature JUnitWrapper {
+			WrapToJUnit = "true"
+		}
+
+		feature FunctionInlining {
+			inlineReactions = false
+			inlineEntryActions = false
+			inlineExitActions = false
+			inlineEnterSequences = false
+			inlineExitSequences = false
+			inlineChoices = false
+			inlineEnterRegion = false
+			inlineExitRegion = false
+			inlineEntries = false
+		}
+	}
 }

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

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

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/TypeAliasTest/TypeAlias.sgen

@@ -0,0 +1,19 @@
+GeneratorModel for yakindu::cpp {
+	statechart TypeAlias {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "TypeAliasTest"
+		}
+		feature FunctionInlining {
+			inlineReactions = false
+			inlineEntryActions = false
+			inlineEnterSequences = false 
+			inlineExitActions = false
+			inlineExitSequences = false
+			inlineChoices = false
+			inlineEntries = false
+			inlineEnterRegion = false
+			inlineExitRegion = false
+		}
+	}
+}

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/TypeAliasTest/TypeAliasTest.cc

@@ -0,0 +1,30 @@
+/**
+* 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
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "TypeAlias.h"
+
+TEST(StatemachineTest, TypeAliasTest) {
+	TypeAlias* statechart = new TypeAlias();
+	statechart->init();
+	statechart->enter();
+	EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_Start));
+	EXPECT_TRUE(statechart->getDefaultSCI()->get_myVar()== 1l);
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_Mid));
+	EXPECT_TRUE(statechart->getDefaultSCI()->get_myString()== "TypeSystem");
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_Mid2));
+	statechart->raise_myEvent();
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_End));
+	delete statechart;
+}

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

@@ -1395,4 +1395,28 @@ GeneratorModel for sctunit::cpp {
 			inlineEntries = false
 		}	
 	}
+	
+	test TypeAlias {
+		
+		feature Outlet{ 
+			targetProject = "org.yakindu.sct.generator.cpp.test" 
+			targetFolder = "test-gen"			
+		}		
+		
+		feature JUnitWrapper {
+			WrapToJUnit =  "true"
+		}				
+				
+		feature FunctionInlining {
+			inlineReactions = false
+			inlineEntryActions = false
+			inlineExitActions = false
+			inlineEnterSequences = false
+			inlineExitSequences = false
+			inlineChoices = false
+			inlineEnterRegion = false
+			inlineExitRegion = false
+			inlineEntries = false
+		}	
+	}
 }

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

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

test-plugins/org.yakindu.sct.generator.cpp.test/test-gen/org/yakindu/sct/generator/cpp/test/TypeAliasTest.java

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

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

@@ -1421,6 +1421,30 @@ GeneratorModel for yakindu::java {
 			inlineEntries = false
 		}
 	}
+	
+	statechart TypeAlias {
+		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 TimedTransitions {
 		feature Outlet {

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

@@ -8,7 +8,6 @@ GeneratorModel for sctunit::java {
 		}			
 	}
 
-	
 	test AlwaysOncycle{
 		
 		feature Outlet{ 
@@ -16,14 +15,14 @@ GeneratorModel for sctunit::java {
 			targetFolder = "test-gen"			
 		}			
 	}
-	
+	 
 	test AssignmentAsExpression{
 		
 		feature Outlet{ 
 			targetProject = "org.yakindu.sct.generator.java.test" 
 			targetFolder = "test-gen"			
 		}			
-	}
+	} 
 	
 	test BitExpressions{
 		
@@ -451,6 +450,14 @@ GeneratorModel for sctunit::java {
 			targetFolder = "test-gen"			
 		}			
 	}
+	
+	test TypeAlias{
+		
+		feature Outlet{ 
+			targetProject = "org.yakindu.sct.generator.java.test" 
+			targetFolder = "test-gen"			
+		}			
+	}
 
 
 	test TransitionWithoutCondition{

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/typealias/ITypeAliasStatemachine.java

@@ -0,0 +1,23 @@
+package org.yakindu.scr.typealias;
+
+import org.yakindu.scr.IStatemachine;
+
+public interface ITypeAliasStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+	
+		public void raiseMyEvent();
+		
+		public long getMyVar();
+		
+		public void setMyVar(long value);
+		
+		public String getMyString();
+		
+		public void setMyString(String value);
+		
+	}
+	
+	public SCInterface getSCInterface();
+	
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/typealias/TypeAliasStatemachine.java

@@ -0,0 +1,320 @@
+package org.yakindu.scr.typealias;
+
+public class TypeAliasStatemachine implements ITypeAliasStatemachine {
+
+	protected class SCInterfaceImpl implements SCInterface {
+	
+		private boolean myEvent;
+		
+		public void raiseMyEvent() {
+			myEvent = true;
+		}
+		
+		private long myVar;
+		
+		public long getMyVar() {
+			return myVar;
+		}
+		
+		public void setMyVar(long value) {
+			this.myVar = value;
+		}
+		
+		private String myString;
+		
+		public String getMyString() {
+			return myString;
+		}
+		
+		public void setMyString(String value) {
+			this.myString = value;
+		}
+		
+		protected void clearEvents() {
+			myEvent = false;
+		}
+	}
+	
+	protected SCInterfaceImpl sCInterface;
+	
+	private boolean initialized = false;
+	
+	public enum State {
+		main_region_Start,
+		main_region_Mid,
+		main_region_Mid2,
+		main_region_End,
+		$NullState$
+	};
+	
+	private final State[] stateVector = new State[1];
+	
+	private int nextStateIndex;
+	
+	public TypeAliasStatemachine() {
+		sCInterface = new SCInterfaceImpl();
+	}
+	
+	public void init() {
+		this.initialized = true;
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+		clearEvents();
+		clearOutEvents();
+		sCInterface.setMyVar(0);
+		
+		sCInterface.setMyString("");
+	}
+	
+	public void enter() {
+		if (!initialized) {
+			throw new IllegalStateException(
+					"The state machine needs to be initialized first by calling the init() function.");
+		}
+		enterSequence_main_region_default();
+	}
+	
+	public void exit() {
+		exitSequence_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 main_region_Start:
+			return stateVector[0] == State.main_region_Start;
+		case main_region_Mid:
+			return stateVector[0] == State.main_region_Mid;
+		case main_region_Mid2:
+			return stateVector[0] == State.main_region_Mid2;
+		case main_region_End:
+			return stateVector[0] == State.main_region_End;
+		default:
+			return false;
+		}
+	}
+	
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+	
+	public void raiseMyEvent() {
+		sCInterface.raiseMyEvent();
+	}
+	
+	public long getMyVar() {
+		return sCInterface.getMyVar();
+	}
+	
+	public void setMyVar(long value) {
+		sCInterface.setMyVar(value);
+	}
+	
+	public String getMyString() {
+		return sCInterface.getMyString();
+	}
+	
+	public void setMyString(String value) {
+		sCInterface.setMyString(value);
+	}
+	
+	private boolean check_main_region_Start_tr0_tr0() {
+		return sCInterface.getMyVar()==1;
+	}
+	
+	private boolean check_main_region_Mid_tr0_tr0() {
+		return sCInterface.getMyString()=="TypeSystem";
+	}
+	
+	private boolean check_main_region_Mid2_tr0_tr0() {
+		return sCInterface.myEvent;
+	}
+	
+	private void effect_main_region_Start_tr0() {
+		exitSequence_main_region_Start();
+		enterSequence_main_region_Mid_default();
+	}
+	
+	private void effect_main_region_Mid_tr0() {
+		exitSequence_main_region_Mid();
+		enterSequence_main_region_Mid2_default();
+	}
+	
+	private void effect_main_region_Mid2_tr0() {
+		exitSequence_main_region_Mid2();
+		enterSequence_main_region_End_default();
+	}
+	
+	/* Entry action for state 'Start'. */
+	private void entryAction_main_region_Start() {
+		sCInterface.setMyVar(1);
+	}
+	
+	/* Entry action for state 'Mid'. */
+	private void entryAction_main_region_Mid() {
+		sCInterface.setMyString("TypeSystem");
+	}
+	
+	/* 'default' enter sequence for state Start */
+	private void enterSequence_main_region_Start_default() {
+		entryAction_main_region_Start();
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_Start;
+	}
+	
+	/* 'default' enter sequence for state Mid */
+	private void enterSequence_main_region_Mid_default() {
+		entryAction_main_region_Mid();
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_Mid;
+	}
+	
+	/* 'default' enter sequence for state Mid2 */
+	private void enterSequence_main_region_Mid2_default() {
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_Mid2;
+	}
+	
+	/* 'default' enter sequence for state End */
+	private void enterSequence_main_region_End_default() {
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_End;
+	}
+	
+	/* 'default' enter sequence for region main region */
+	private void enterSequence_main_region_default() {
+		react_main_region__entry_Default();
+	}
+	
+	/* Default exit sequence for state Start */
+	private void exitSequence_main_region_Start() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+	}
+	
+	/* Default exit sequence for state Mid */
+	private void exitSequence_main_region_Mid() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+	}
+	
+	/* Default exit sequence for state Mid2 */
+	private void exitSequence_main_region_Mid2() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+	}
+	
+	/* Default exit sequence for state End */
+	private void exitSequence_main_region_End() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+	}
+	
+	/* Default exit sequence for region main region */
+	private void exitSequence_main_region() {
+		switch (stateVector[0]) {
+		case main_region_Start:
+			exitSequence_main_region_Start();
+			break;
+		case main_region_Mid:
+			exitSequence_main_region_Mid();
+			break;
+		case main_region_Mid2:
+			exitSequence_main_region_Mid2();
+			break;
+		case main_region_End:
+			exitSequence_main_region_End();
+			break;
+		default:
+			break;
+		}
+	}
+	
+	/* The reactions of state Start. */
+	private void react_main_region_Start() {
+		if (check_main_region_Start_tr0_tr0()) {
+			effect_main_region_Start_tr0();
+		}
+	}
+	
+	/* The reactions of state Mid. */
+	private void react_main_region_Mid() {
+		if (check_main_region_Mid_tr0_tr0()) {
+			effect_main_region_Mid_tr0();
+		}
+	}
+	
+	/* The reactions of state Mid2. */
+	private void react_main_region_Mid2() {
+		if (check_main_region_Mid2_tr0_tr0()) {
+			effect_main_region_Mid2_tr0();
+		}
+	}
+	
+	/* The reactions of state End. */
+	private void react_main_region_End() {
+	}
+	
+	/* Default react sequence for initial entry  */
+	private void react_main_region__entry_Default() {
+		enterSequence_main_region_Start_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 main_region_Start:
+				react_main_region_Start();
+				break;
+			case main_region_Mid:
+				react_main_region_Mid();
+				break;
+			case main_region_Mid2:
+				react_main_region_Mid2();
+				break;
+			case main_region_End:
+				react_main_region_End();
+				break;
+			default:
+				// $NullState$
+			}
+		}
+		clearEvents();
+	}
+}

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

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

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

@@ -0,0 +1,53 @@
+/**
+* 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.typealias.TypeAliasStatemachine;
+import org.yakindu.scr.typealias.TypeAliasStatemachine.State;
+/**
+ *  Unit TestCase for TypeAlias
+ */
+@SuppressWarnings("all")
+public class TypeAliasTest {
+
+	private TypeAliasStatemachine statemachine;
+
+	@Before
+	public void setUp() {
+		statemachine = new TypeAliasStatemachine();
+		statemachine.init();
+	}
+
+	@After
+	public void tearDown() {
+		statemachine = null;
+	}
+
+	@Test
+	public void testTypeAliasTest() {
+		statemachine.enter();
+		assertTrue(statemachine.isStateActive(State.main_region_Start));
+		assertTrue(statemachine.getMyVar() == 1l);
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Mid));
+		assertTrue(statemachine.getMyString() == "TypeSystem");
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_Mid2));
+		statemachine.raiseMyEvent();
+		statemachine.runCycle();
+		assertTrue(statemachine.isStateActive(State.main_region_End));
+	}
+}

test-plugins/org.yakindu.sct.test.models/tests/AllTests.sctunit

@@ -55,7 +55,8 @@ testsuite AllTests {
 	TransitionWithoutCondition,
 	TriggerGuardExpressions,
 	TriggerExpressionPrecedence,
-	ValuedEvents
+	ValuedEvents,
+	TypeAlias
 	//Add the following tests if sct unit Java and C++ generators
 	// support mock timer service generation
 	//StatemachineKeywords,