[YAKHMI-852] New Tests

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

@@ -0,0 +1,32 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "AlwaysOncycle.h"
+
+TEST(StatemachineTest, alwaysOncycleTest) {
+	AlwaysOncycle handle;
+	alwaysOncycle_init(&handle);
+	alwaysOncycle_enter(&handle);
+	EXPECT_TRUE(alwaysOncycle_isActive(&handle, AlwaysOncycle_main_region_StateA));
+	while (alwaysOncycleIface_get_value(&handle) < 5) {
+		alwaysOncycle_runCycle(&handle);
+		EXPECT_TRUE(alwaysOncycle_isActive(&handle, AlwaysOncycle_main_region_StateA));
+	}
+	alwaysOncycle_runCycle(&handle);
+	EXPECT_TRUE(alwaysOncycle_isActive(&handle, AlwaysOncycle_main_region_StateB));
+	while (alwaysOncycleIface_get_value(&handle) < 5) {
+		alwaysOncycle_runCycle(&handle);
+		EXPECT_TRUE(alwaysOncycle_isActive(&handle, AlwaysOncycle_main_region_StateB));
+	}
+	alwaysOncycle_runCycle(&handle);
+	EXPECT_TRUE(alwaysOncycle_isActive(&handle, AlwaysOncycle_main_region_StateA));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart AlwaysOncycle {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "AlwaysOncycle"
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "AssignmentAsExpression.h"
+
+TEST(StatemachineTest, simpleAssignment) {
+	AssignmentAsExpression handle;
+	assignmentAsExpression_init(&handle);
+	assignmentAsExpression_enter(&handle);
+	EXPECT_TRUE(assignmentAsExpression_isActive(&handle, AssignmentAsExpression_main_region_Add));
+	EXPECT_TRUE(assignmentAsExpressionIface_get_b(&handle) == 5);
+	EXPECT_TRUE(assignmentAsExpressionIface_get_a(&handle) == 9);
+	assignmentAsExpression_runCycle(&handle);
+	EXPECT_TRUE(assignmentAsExpression_isActive(&handle, AssignmentAsExpression_main_region_Subtract));
+	EXPECT_TRUE(assignmentAsExpressionIface_get_d(&handle) == 6);
+	assignmentAsExpression_runCycle(&handle);
+	EXPECT_TRUE(assignmentAsExpression_isActive(&handle, AssignmentAsExpression_main_region_Multiply));
+	EXPECT_TRUE(assignmentAsExpressionIface_get_e(&handle) == 15);
+	assignmentAsExpression_runCycle(&handle);
+	EXPECT_TRUE(assignmentAsExpression_isActive(&handle, AssignmentAsExpression_main_region_Divide));
+	EXPECT_TRUE(assignmentAsExpressionIface_get_g(&handle) == 1);
+	assignmentAsExpression_runCycle(&handle);
+	EXPECT_TRUE(assignmentAsExpression_isActive(&handle, AssignmentAsExpression_main_region_Modulo));
+	EXPECT_TRUE(assignmentAsExpressionIface_get_i(&handle) == 1);
+	assignmentAsExpression_runCycle(&handle);
+	EXPECT_TRUE(assignmentAsExpression_isActive(&handle, AssignmentAsExpression_main_region_Shift));
+	EXPECT_TRUE(assignmentAsExpressionIface_get_j(&handle) == 16);
+	EXPECT_TRUE(assignmentAsExpressionIface_get_k(&handle) == 4);
+	assignmentAsExpression_runCycle(&handle);
+	EXPECT_TRUE(assignmentAsExpression_isActive(&handle, AssignmentAsExpression_main_region_boolean_And));
+	EXPECT_TRUE(assignmentAsExpressionIface_get_l(&handle) == 1);
+	assignmentAsExpression_runCycle(&handle);
+	EXPECT_TRUE(assignmentAsExpression_isActive(&handle, AssignmentAsExpression_main_region_boolean_Or));
+	EXPECT_TRUE(assignmentAsExpressionIface_get_p(&handle) == 15);
+	assignmentAsExpression_runCycle(&handle);
+	EXPECT_TRUE(assignmentAsExpression_isActive(&handle, AssignmentAsExpression_main_region_boolean_Xor));
+	EXPECT_TRUE(assignmentAsExpressionIface_get_u(&handle) == 12);
+	assignmentAsExpression_exit(&handle);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart AssignmentAsExpression {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "AssignmentAsExpression"
+		}
+	}
+}

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

@@ -0,0 +1,31 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "BitExpressions.h"
+
+TEST(StatemachineTest, BitExpressions) {
+	BitExpressions handle;
+	bitExpressions_init(&handle);
+	bitExpressions_enter(&handle);
+	EXPECT_TRUE(bitExpressions_isActive(&handle, BitExpressions_main_region_StateA));
+	EXPECT_TRUE(bitExpressionsIface_get_myBit1(&handle) == 5);
+	EXPECT_TRUE(bitExpressionsIface_get_myBit2(&handle) == 7);
+	bitExpressionsIface_raise_e1(&handle);
+	bitExpressions_runCycle(&handle);
+	EXPECT_TRUE(bitExpressions_isActive(&handle, BitExpressions_main_region_StateB));
+	EXPECT_TRUE(bitExpressionsIface_get_leftBitshift(&handle) == 10);
+	EXPECT_TRUE(bitExpressionsIface_get_rightBitshift(&handle) == 2);
+	EXPECT_TRUE(bitExpressionsIface_get_complementBitshift(&handle) == - 6 );
+	EXPECT_TRUE(bitExpressionsIface_get_bitwiseAnd(&handle) == 5);
+	EXPECT_TRUE(bitExpressionsIface_get_bitwiseOr(&handle) == 7);
+	EXPECT_TRUE(bitExpressionsIface_get_bitwiseXor(&handle) == 2);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart BitExpressions {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "BitExpressions"
+		}
+	}
+}

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

@@ -0,0 +1,30 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "BooleanExpressions.h"
+
+TEST(StatemachineTest, booleanExpressions) {
+	BooleanExpressions handle;
+	booleanExpressions_init(&handle);
+	booleanExpressions_enter(&handle);
+	EXPECT_TRUE(booleanExpressions_isActive(&handle, BooleanExpressions_main_region_StateA));
+	EXPECT_TRUE(booleanExpressionsIface_get_myBool1(&handle) == true);
+	EXPECT_TRUE(booleanExpressionsIface_get_myBool2(&handle) == false);
+	booleanExpressionsIface_raise_e1(&handle);
+	booleanExpressions_runCycle(&handle);
+	EXPECT_TRUE(booleanExpressions_isActive(&handle, BooleanExpressions_main_region_StateB));
+	EXPECT_TRUE(booleanExpressionsIface_get_and(&handle) == false);
+	EXPECT_TRUE(booleanExpressionsIface_get_or(&handle) == true);
+	EXPECT_TRUE(booleanExpressionsIface_get_not(&handle) == false);
+	EXPECT_TRUE(booleanExpressionsIface_get_equal(&handle) == false);
+	EXPECT_TRUE(booleanExpressionsIface_get_notequal(&handle) == true);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart BooleanExpressions {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "BooleanExpressions"
+		}
+	}
+}

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

@@ -0,0 +1,25 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "CKeywords.h"
+
+TEST(StatemachineTest, CKeywordsTest) {
+	CKeywords handle;
+	cKeywords_init(&handle);
+	cKeywords_enter(&handle);
+	EXPECT_TRUE(cKeywords_isActive(&handle, CKeywords_auto_char));
+	cKeywordsIface_raise_auto(&handle);
+	cKeywords_runCycle(&handle);
+	EXPECT_TRUE(cKeywords_isActive(&handle, CKeywords_auto_const));
+	EXPECT_TRUE(cKeywords_isActive(&handle, CKeywords_auto_const_switch_case));
+	EXPECT_TRUE(cKeywords_isActive(&handle, CKeywords_auto_const_switch_case_enum_asm));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart CKeywords {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "CKeywords"
+		}
+	}
+}

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

@@ -0,0 +1,84 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "Choice.h"
+
+TEST(StatemachineTest, elseChoiceUsingNonDefaultTransition) {
+	Choice handle;
+	choice_init(&handle);
+	choice_enter(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_A));
+	choiceIface_set_c(&handle, true);
+	choiceIface_raise_e(&handle);
+	choice_runCycle(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_C));
+}
+TEST(StatemachineTest, elseChoiceUsingDefaultTransition) {
+	Choice handle;
+	choice_init(&handle);
+	choice_enter(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_A));
+	choiceIface_set_c(&handle, false);
+	choiceIface_raise_e(&handle);
+	choice_runCycle(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_B));
+}
+TEST(StatemachineTest, defaultChoiceUsingNonDefaultTransition) {
+	Choice handle;
+	choice_init(&handle);
+	choice_enter(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_A));
+	choiceIface_set_c(&handle, true);
+	choiceIface_raise_g(&handle);
+	choice_runCycle(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_C));
+}
+TEST(StatemachineTest, defaultChoiceUsingDefaultTransition) {
+	Choice handle;
+	choice_init(&handle);
+	choice_enter(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_A));
+	choiceIface_set_c(&handle, false);
+	choiceIface_raise_g(&handle);
+	choice_runCycle(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_B));
+}
+TEST(StatemachineTest, uncheckedChoiceUsingNonDefaultTransition) {
+	Choice handle;
+	choice_init(&handle);
+	choice_enter(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_A));
+	choiceIface_set_c(&handle, true);
+	choiceIface_raise_f(&handle);
+	choice_runCycle(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_C));
+}
+TEST(StatemachineTest, uncheckedChoiceUsingDefaultTransition) {
+	Choice handle;
+	choice_init(&handle);
+	choice_enter(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_A));
+	choiceIface_set_c(&handle, false);
+	choiceIface_raise_f(&handle);
+	choice_runCycle(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_B));
+}
+TEST(StatemachineTest, alwaysTrueTransitionInChoice) {
+	Choice handle;
+	choice_init(&handle);
+	choice_enter(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_A));
+	choiceIface_set_c(&handle, true);
+	choiceIface_raise_h(&handle);
+	choice_runCycle(&handle);
+	EXPECT_TRUE(choice_isActive(&handle, Choice_main_region_B));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart Choice {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "Choice"
+		}
+	}
+}

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

@@ -0,0 +1,19 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "Declarations.h"
+
+TEST(StatemachineTest, declarationsTest) {
+	Declarations handle;
+	declarations_init(&handle);
+	declarations_enter(&handle);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart Declarations {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "Declarations"
+		}
+	}
+}

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

@@ -0,0 +1,37 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "DeepHistory.h"
+
+TEST(StatemachineTest, deepHistoryTest) {
+	DeepHistory handle;
+	deepHistory_init(&handle);
+	deepHistory_enter(&handle);
+	deepHistoryIface_raise_event1(&handle);
+	deepHistory_runCycle(&handle);
+	deepHistoryIface_raise_event3(&handle);
+	deepHistory_runCycle(&handle);
+	deepHistoryIface_raise_event5(&handle);
+	deepHistory_runCycle(&handle);
+	deepHistoryIface_raise_event7(&handle);
+	deepHistory_runCycle(&handle);
+	EXPECT_TRUE(!deepHistory_isActive(&handle, DeepHistory_mainRegion_State1));
+	EXPECT_TRUE(deepHistory_isActive(&handle, DeepHistory_mainRegion_State2__region0_State4__region0_State7__region0_State9));
+	deepHistoryIface_raise_event2(&handle);
+	deepHistory_runCycle(&handle);
+	EXPECT_TRUE(deepHistory_isActive(&handle, DeepHistory_mainRegion_State1));
+	EXPECT_TRUE(!deepHistory_isActive(&handle, DeepHistory_mainRegion_State2__region0_State4__region0_State7__region0_State9));
+	deepHistoryIface_raise_event1(&handle);
+	deepHistory_runCycle(&handle);
+	EXPECT_TRUE(!deepHistory_isActive(&handle, DeepHistory_mainRegion_State1));
+	EXPECT_TRUE(deepHistory_isActive(&handle, DeepHistory_mainRegion_State2__region0_State4__region0_State7__region0_State9));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart DeepHistory {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "DeepHistory"
+		}
+	}
+}

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

@@ -0,0 +1,41 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "EnterState.h"
+
+TEST(StatemachineTest, defaultEntry) {
+	EnterState handle;
+	enterState_init(&handle);
+	enterState_enter(&handle);
+	EXPECT_TRUE(enterState_isActive(&handle, EnterState_r_A));
+	enterStateIface_raise_e(&handle);
+	enterState_runCycle(&handle);
+	EXPECT_TRUE(enterState_isActive(&handle, EnterState_r_B_r_E));
+}
+TEST(StatemachineTest, namedEntryThroughNamedTransition) {
+	EnterState handle;
+	enterState_init(&handle);
+	enterState_enter(&handle);
+	EXPECT_TRUE(enterState_isActive(&handle, EnterState_r_A));
+	enterStateIface_raise_f(&handle);
+	enterState_runCycle(&handle);
+	EXPECT_TRUE(enterState_isActive(&handle, EnterState_r_B_r_F));
+}
+TEST(StatemachineTest, namedEntryThroughDefaultTransition) {
+	EnterState handle;
+	enterState_init(&handle);
+	enterState_enter(&handle);
+	EXPECT_TRUE(enterState_isActive(&handle, EnterState_r_A));
+	enterStateIface_raise_g(&handle);
+	enterState_runCycle(&handle);
+	EXPECT_TRUE(enterState_isActive(&handle, EnterState_r_B_r_E));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart EnterState {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "EnterState"
+		}
+	}
+}

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

@@ -0,0 +1,30 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "ExitOnSelfTransition.h"
+
+TEST(StatemachineTest, ExitOnSelfTransitionTest) {
+	ExitOnSelfTransition handle;
+	exitOnSelfTransition_init(&handle);
+	exitOnSelfTransition_enter(&handle);
+	EXPECT_TRUE(exitOnSelfTransition_isActive(&handle, ExitOnSelfTransition_main_region_A));
+	EXPECT_TRUE(exitOnSelfTransitionIface_get_entryCount(&handle) == 1);
+	EXPECT_TRUE(exitOnSelfTransitionIface_get_exitCount(&handle) == 0);
+	exitOnSelfTransitionIface_raise_e(&handle);
+	exitOnSelfTransition_runCycle(&handle);
+	EXPECT_TRUE(exitOnSelfTransitionIface_get_entryCount(&handle) == 2);
+	EXPECT_TRUE(exitOnSelfTransitionIface_get_exitCount(&handle) == 1);
+	exitOnSelfTransitionIface_raise_f(&handle);
+	exitOnSelfTransition_runCycle(&handle);
+	EXPECT_TRUE(exitOnSelfTransitionIface_get_entryCount(&handle) == 2);
+	EXPECT_TRUE(exitOnSelfTransitionIface_get_exitCount(&handle) == 2);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart ExitOnSelfTransition {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "ExitOnSelfTransition"
+		}
+	}
+}

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

@@ -0,0 +1,49 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "ExitState.h"
+
+TEST(StatemachineTest, defaultExit) {
+	ExitState handle;
+	exitState_init(&handle);
+	exitState_enter(&handle);
+	EXPECT_TRUE(exitState_isActive(&handle, ExitState_r_A));
+	exitStateIface_raise_e(&handle);
+	exitState_runCycle(&handle);
+	EXPECT_TRUE(exitState_isActive(&handle, ExitState_r_E));
+}
+TEST(StatemachineTest, namedExitThroughNamedTransition) {
+	ExitState handle;
+	exitState_init(&handle);
+	exitState_enter(&handle);
+	EXPECT_TRUE(exitState_isActive(&handle, ExitState_r_A));
+	exitStateIface_raise_f(&handle);
+	exitState_runCycle(&handle);
+	EXPECT_TRUE(exitState_isActive(&handle, ExitState_r_F));
+}
+TEST(StatemachineTest, namedExitThroughDefaultTransition) {
+	ExitState handle;
+	exitState_init(&handle);
+	exitState_enter(&handle);
+	EXPECT_TRUE(exitState_isActive(&handle, ExitState_r_A));
+	exitStateIface_raise_g(&handle);
+	exitState_runCycle(&handle);
+	EXPECT_TRUE(exitState_isActive(&handle, ExitState_r_E));
+}
+TEST(StatemachineTest, remainInA) {
+	ExitState handle;
+	exitState_init(&handle);
+	exitState_enter(&handle);
+	EXPECT_TRUE(exitState_isActive(&handle, ExitState_r_A));
+	exitState_runCycle(&handle);
+	EXPECT_TRUE(exitState_isActive(&handle, ExitState_r_A));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart ExitState {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "ExitState"
+		}
+	}
+}

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

@@ -0,0 +1,22 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "FeatureCalls.h"
+
+TEST(StatemachineTest, FeatureCalls) {
+	FeatureCalls handle;
+	featureCalls_init(&handle);
+	featureCalls_enter(&handle);
+	EXPECT_TRUE(featureCalls_isActive(&handle, FeatureCalls_main_region_A));
+	featureCalls_runCycle(&handle);
+	EXPECT_TRUE(featureCalls_isActive(&handle, FeatureCalls_main_region_A));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart FeatureCalls {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "FeatureCalls"
+		}
+	}
+}

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

@@ -0,0 +1,35 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "Guard.h"
+
+TEST(StatemachineTest, guardTest) {
+	Guard handle;
+	guard_init(&handle);
+	guard_enter(&handle);
+	EXPECT_TRUE(guard_isActive(&handle, Guard_main_region_A));
+	guardIface_raise_event1(&handle);
+	guard_runCycle(&handle);
+	EXPECT_TRUE(guard_isActive(&handle, Guard_main_region_A));
+	guardIface_raise_event2(&handle);
+	guard_runCycle(&handle);
+	EXPECT_TRUE(guard_isActive(&handle, Guard_main_region_B));
+	guardIface_raise_return(&handle);
+	guard_runCycle(&handle);
+	EXPECT_TRUE(guard_isActive(&handle, Guard_main_region_A));
+	guardIface_raise_event1(&handle);
+	guard_runCycle(&handle);
+	EXPECT_TRUE(guard_isActive(&handle, Guard_main_region_B));
+	guardIface_raise_return(&handle);
+	guard_runCycle(&handle);
+	EXPECT_TRUE(guard_isActive(&handle, Guard_main_region_A));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart Guard {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "Guard"
+		}
+	}
+}

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

@@ -0,0 +1,60 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "GuardedEntry.h"
+
+TEST(StatemachineTest, EntryNotTakenOnStatechartEnter) {
+	GuardedEntry handle;
+	guardedEntry_init(&handle);
+	EXPECT_TRUE(guardedEntryIface_get_guard(&handle) == false);
+	guardedEntry_enter(&handle);
+	EXPECT_TRUE(guardedEntry_isActive(&handle, GuardedEntry_main_region_A));
+	EXPECT_TRUE(guardedEntryIface_get_done(&handle) == false);
+}
+TEST(StatemachineTest, EntryTakenOnStatechartEnter) {
+	GuardedEntry handle;
+	guardedEntry_init(&handle);
+	guardedEntryIface_set_guard(&handle, true);
+	guardedEntry_enter(&handle);
+	EXPECT_TRUE(guardedEntry_isActive(&handle, GuardedEntry_main_region_A));
+	EXPECT_TRUE(guardedEntryIface_get_done(&handle) == true);
+}
+TEST(StatemachineTest, EntryTakenInTransition) {
+	GuardedEntry handle;
+	guardedEntry_init(&handle);
+	guardedEntry_enter(&handle);
+	EXPECT_TRUE(guardedEntry_isActive(&handle, GuardedEntry_main_region_A));
+	guardedEntryIface_raise_e(&handle);
+	guardedEntry_runCycle(&handle);
+	EXPECT_TRUE(guardedEntry_isActive(&handle, GuardedEntry_main_region_B));
+	guardedEntryIface_set_guard(&handle, true);
+	guardedEntryIface_set_done(&handle, false);
+	guardedEntryIface_raise_e(&handle);
+	guardedEntry_runCycle(&handle);
+	EXPECT_TRUE(guardedEntry_isActive(&handle, GuardedEntry_main_region_A));
+	EXPECT_TRUE(guardedEntryIface_get_done(&handle) );
+}
+TEST(StatemachineTest, EntryNotTakenInTransition) {
+	GuardedEntry handle;
+	guardedEntry_init(&handle);
+	guardedEntry_enter(&handle);
+	EXPECT_TRUE(guardedEntry_isActive(&handle, GuardedEntry_main_region_A));
+	guardedEntryIface_raise_e(&handle);
+	guardedEntry_runCycle(&handle);
+	EXPECT_TRUE(guardedEntry_isActive(&handle, GuardedEntry_main_region_B));
+	guardedEntryIface_set_guard(&handle, false);
+	guardedEntryIface_set_done(&handle, false);
+	guardedEntryIface_raise_e(&handle);
+	guardedEntry_runCycle(&handle);
+	EXPECT_TRUE(guardedEntry_isActive(&handle, GuardedEntry_main_region_A));
+	EXPECT_TRUE(!guardedEntryIface_get_done(&handle) );
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart GuardedEntry {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "GuardedEntry"
+		}
+	}
+}

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

@@ -0,0 +1,36 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "GuardedExit.h"
+
+TEST(StatemachineTest, ExitTaken) {
+	GuardedExit handle;
+	guardedExit_init(&handle);
+	guardedExit_enter(&handle);
+	EXPECT_TRUE(guardedExit_isActive(&handle, GuardedExit_main_region_A));
+	EXPECT_TRUE(!guardedExitIface_get_guard(&handle) );
+	guardedExitIface_raise_e(&handle);
+	guardedExit_runCycle(&handle);
+	EXPECT_TRUE(guardedExit_isActive(&handle, GuardedExit_main_region_B));
+	EXPECT_TRUE(!guardedExitIface_get_done(&handle) );
+}
+TEST(StatemachineTest, ExitNotTaken) {
+	GuardedExit handle;
+	guardedExit_init(&handle);
+	guardedExit_enter(&handle);
+	EXPECT_TRUE(guardedExit_isActive(&handle, GuardedExit_main_region_A));
+	guardedExitIface_set_guard(&handle, true);
+	guardedExitIface_raise_e(&handle);
+	guardedExit_runCycle(&handle);
+	EXPECT_TRUE(guardedExit_isActive(&handle, GuardedExit_main_region_B));
+	EXPECT_TRUE(guardedExitIface_get_done(&handle) );
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart GuardedExit {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "GuardedExit"
+		}
+	}
+}

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

@@ -0,0 +1,58 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "HistoryWithoutInitialStep.h"
+
+TEST(StatemachineTest, enterThroughInitialEntry) {
+	HistoryWithoutInitialStep handle;
+	historyWithoutInitialStep_init(&handle);
+	historyWithoutInitialStep_enter(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_A));
+	historyWithoutInitialStepIface_raise_e1(&handle);
+	historyWithoutInitialStep_runCycle(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_B_r1_C));
+	historyWithoutInitialStepIface_raise_e2(&handle);
+	historyWithoutInitialStep_runCycle(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_B_r1_D));
+}
+TEST(StatemachineTest, enterCThroughHistory) {
+	HistoryWithoutInitialStep handle;
+	historyWithoutInitialStep_init(&handle);
+	historyWithoutInitialStep_enter(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_A));
+	historyWithoutInitialStepIface_raise_e1(&handle);
+	historyWithoutInitialStep_runCycle(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_B_r1_C));
+	historyWithoutInitialStepIface_raise_e1(&handle);
+	historyWithoutInitialStep_runCycle(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_A));
+	historyWithoutInitialStepIface_raise_e2(&handle);
+	historyWithoutInitialStep_runCycle(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_B_r1_C));
+}
+TEST(StatemachineTest, enterDThroughHistory) {
+	HistoryWithoutInitialStep handle;
+	historyWithoutInitialStep_init(&handle);
+	historyWithoutInitialStep_enter(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_A));
+	historyWithoutInitialStepIface_raise_e1(&handle);
+	historyWithoutInitialStep_runCycle(&handle);
+	historyWithoutInitialStepIface_raise_e2(&handle);
+	historyWithoutInitialStep_runCycle(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_B_r1_D));
+	historyWithoutInitialStepIface_raise_e1(&handle);
+	historyWithoutInitialStep_runCycle(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_A));
+	historyWithoutInitialStepIface_raise_e2(&handle);
+	historyWithoutInitialStep_runCycle(&handle);
+	EXPECT_TRUE(historyWithoutInitialStep_isActive(&handle, HistoryWithoutInitialStep_main_region_B_r1_D));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart HistoryWithoutInitialStep {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "HistoryWithoutInitialStep"
+		}
+	}
+}

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

@@ -0,0 +1,23 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "InEventLifeCycle.h"
+
+TEST(StatemachineTest, eventLifeCycle) {
+	InEventLifeCycle handle;
+	inEventLifeCycle_init(&handle);
+	inEventLifeCycle_enter(&handle);
+	inEventLifeCycleIface_raise_e(&handle);
+	EXPECT_TRUE(inEventLifeCycleIface_get_i(&handle) == 0);
+	inEventLifeCycle_runCycle(&handle);
+	EXPECT_TRUE(inEventLifeCycleIface_get_i(&handle) == 1);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart InEventLifeCycle {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "InEventLifeCycle"
+		}
+	}
+}

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

@@ -0,0 +1,41 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "IntegerExpressions.h"
+
+TEST(StatemachineTest, integerExpressions) {
+	IntegerExpressions handle;
+	integerExpressions_init(&handle);
+	integerExpressions_enter(&handle);
+	EXPECT_TRUE(integerExpressions_isActive(&handle, IntegerExpressions_main_region_StateA));
+	EXPECT_TRUE(integerExpressionsIface_get_myInt1(&handle) == 10);
+	EXPECT_TRUE(integerExpressionsIface_get_myInt2(&handle) == 5);
+	integerExpressionsIface_raise_e1(&handle);
+	integerExpressions_runCycle(&handle);
+	EXPECT_TRUE(integerExpressionsIface_get_less(&handle) == false);
+	EXPECT_TRUE(integerExpressionsIface_get_greater(&handle) == true);
+	EXPECT_TRUE(integerExpressionsIface_get_equalOrLess(&handle) == false);
+	EXPECT_TRUE(integerExpressionsIface_get_equalOrGreater(&handle) == true);
+	EXPECT_TRUE(integerExpressionsIface_get_equal(&handle) == false);
+	EXPECT_TRUE(integerExpressionsIface_get_notEqual(&handle) == true);
+	EXPECT_TRUE(integerExpressionsIface_get_plus(&handle) == 15);
+	EXPECT_TRUE(integerExpressionsIface_get_minus(&handle) == 5);
+	EXPECT_TRUE(integerExpressionsIface_get_multiply(&handle) == 50);
+	EXPECT_TRUE(integerExpressionsIface_get_division(&handle) == 2);
+	EXPECT_TRUE(integerExpressionsIface_get_modulo(&handle) == 0);
+	EXPECT_TRUE(integerExpressionsIface_get_negat(&handle) == - 10 );
+	EXPECT_TRUE(integerExpressionsIface_get_multiAssign(&handle) == 20);
+	EXPECT_TRUE(integerExpressionsIface_get_divAssign(&handle) == 2);
+	EXPECT_TRUE(integerExpressionsIface_get_plusAssign(&handle) == 12);
+	EXPECT_TRUE(integerExpressionsIface_get_minusAssign(&handle) == - 8 );
+	EXPECT_TRUE(integerExpressionsIface_get_moduloAssign(&handle) == 0);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart IntegerExpressions {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "IntegerExpressions"
+		}
+	}
+}

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

@@ -0,0 +1,35 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "InternalEventLifeCycle.h"
+
+TEST(StatemachineTest, InternalEventLifeCycleTest) {
+	InternalEventLifeCycle handle;
+	internalEventLifeCycle_init(&handle);
+	internalEventLifeCycle_enter(&handle);
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r1_A));
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r2_C));
+	internalEventLifeCycleIface_raise_e(&handle);
+	internalEventLifeCycle_runCycle(&handle);
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r1_A));
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r2_D));
+	internalEventLifeCycle_runCycle(&handle);
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r1_A));
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r2_D));
+	internalEventLifeCycleIface_raise_f(&handle);
+	internalEventLifeCycle_runCycle(&handle);
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r1_A));
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r2_C));
+	internalEventLifeCycle_runCycle(&handle);
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r1_A));
+	EXPECT_TRUE(internalEventLifeCycle_isActive(&handle, InternalEventLifeCycle_r2_C));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart InternalEventLifeCycle {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "InternalEventLifeCycle"
+		}
+	}
+}

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

@@ -0,0 +1,27 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "NamedInterfaceAccess.h"
+
+TEST(StatemachineTest, SafeOpenSuccess) {
+	NamedInterfaceAccess handle;
+	namedInterfaceAccess_init(&handle);
+	namedInterfaceAccess_enter(&handle);
+	namedInterfaceAccess_runCycle(&handle);
+	namedInterfaceAccessIfaceUser_raise_numberPressed(&handle, 3);
+	namedInterfaceAccess_runCycle(&handle);
+	namedInterfaceAccessIfaceUser_raise_numberPressed(&handle, 7);
+	namedInterfaceAccess_runCycle(&handle);
+	namedInterfaceAccessIfaceUser_raise_numberPressed(&handle, 5);
+	namedInterfaceAccess_runCycle(&handle);
+	EXPECT_TRUE(namedInterfaceAccessIfaceSafe_israised_open(&handle));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart NamedInterfaceAccess {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "NamedInterfaceAccess"
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "OutEventLifeCycle.h"
+
+TEST(StatemachineTest, availableAfterCycle) {
+	OutEventLifeCycle handle;
+	outEventLifeCycle_init(&handle);
+	outEventLifeCycle_enter(&handle);
+	outEventLifeCycleIface_raise_e(&handle);
+	outEventLifeCycle_runCycle(&handle);
+	EXPECT_TRUE(outEventLifeCycleIface_israised_f(&handle) );
+}
+TEST(StatemachineTest, availableWithinCycle) {
+	OutEventLifeCycle handle;
+	outEventLifeCycle_init(&handle);
+	outEventLifeCycle_enter(&handle);
+	outEventLifeCycleIface_raise_e(&handle);
+	outEventLifeCycle_runCycle(&handle);
+	EXPECT_TRUE(outEventLifeCycleIface_get_f_available_in_cycle(&handle) );
+}
+TEST(StatemachineTest, unvailableWithin2ndCycle) {
+	OutEventLifeCycle handle;
+	outEventLifeCycle_init(&handle);
+	outEventLifeCycle_enter(&handle);
+	outEventLifeCycleIface_raise_e(&handle);
+	outEventLifeCycle_runCycle(&handle);
+	outEventLifeCycle_runCycle(&handle);
+	EXPECT_TRUE(!outEventLifeCycleIface_get_f_available_in_next_cycle(&handle) );
+}
+TEST(StatemachineTest, unvailableAfter2ndCycle) {
+	OutEventLifeCycle handle;
+	outEventLifeCycle_init(&handle);
+	outEventLifeCycle_enter(&handle);
+	outEventLifeCycleIface_raise_e(&handle);
+	outEventLifeCycle_runCycle(&handle);
+	outEventLifeCycle_runCycle(&handle);
+	EXPECT_TRUE(!outEventLifeCycleIface_israised_f(&handle) );
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart OutEventLifeCycle {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "OutEventLifeCycle"
+		}
+	}
+}

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

@@ -0,0 +1,21 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "Parenthesis.h"
+
+TEST(StatemachineTest, simple) {
+	Parenthesis handle;
+	parenthesis_init(&handle);
+	parenthesis_enter(&handle);
+	EXPECT_TRUE(parenthesis_isActive(&handle, Parenthesis_mainRegion_A));
+	EXPECT_TRUE(parenthesisIface_get_erg(&handle) == 8);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart Parenthesis {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "Parenthesis"
+		}
+	}
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart PerformanceTest {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "PerformanceTests"
+		}
+	}
+}

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

@@ -0,0 +1,80 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "PerformanceTest.h"
+
+TEST(StatemachineTest, test_100_000) {
+	PerformanceTest handle;
+	performanceTest_init(&handle);
+	performanceTest_enter(&handle);
+	EXPECT_TRUE(performanceTest_isActive(&handle, PerformanceTest_mr_A));
+	while (performanceTestIface_get_c(&handle) < 100000) {
+		if (performanceTest_isActive(&handle, PerformanceTest_mr_A)) {
+					performanceTestIface_raise_e1(&handle);;
+				  }
+				else {
+					if (performanceTestIface_get_c(&handle) %2== 0) {
+								performanceTestIface_raise_e2(&handle);;
+							  }
+							else {
+								performanceTestIface_raise_e3(&handle);;
+							}
+					;
+				}
+		performanceTest_runCycle(&handle);
+	}
+	EXPECT_TRUE(performanceTestIface_get_a(&handle) > 2);
+}
+TEST(StatemachineTest, test_1_000_000) {
+	PerformanceTest handle;
+	performanceTest_init(&handle);
+	performanceTest_enter(&handle);
+	EXPECT_TRUE(performanceTest_isActive(&handle, PerformanceTest_mr_A));
+	while (performanceTestIface_get_c(&handle) < 1000000) {
+		if (performanceTest_isActive(&handle, PerformanceTest_mr_A)) {
+					performanceTestIface_raise_e1(&handle);;
+				  }
+				else {
+					if (performanceTestIface_get_c(&handle) %2== 0) {
+								performanceTestIface_raise_e2(&handle);;
+							  }
+							else {
+								performanceTestIface_raise_e3(&handle);;
+							}
+					;
+				}
+		performanceTest_runCycle(&handle);
+	}
+	EXPECT_TRUE(performanceTestIface_get_a(&handle) > 2);
+}
+TEST(StatemachineTest, test_10_000_000) {
+	PerformanceTest handle;
+	performanceTest_init(&handle);
+	performanceTest_enter(&handle);
+	EXPECT_TRUE(performanceTest_isActive(&handle, PerformanceTest_mr_A));
+	while (performanceTestIface_get_c(&handle) < 10000000) {
+		if (performanceTest_isActive(&handle, PerformanceTest_mr_A)) {
+					performanceTestIface_raise_e1(&handle);;
+				  }
+				else {
+					if (performanceTestIface_get_c(&handle) %2== 0) {
+								performanceTestIface_raise_e2(&handle);;
+							  }
+							else {
+								performanceTestIface_raise_e3(&handle);;
+							}
+					;
+				}
+		performanceTest_runCycle(&handle);
+	}
+	EXPECT_TRUE(performanceTestIface_get_a(&handle) > 2);
+}

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

@@ -0,0 +1,33 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "PriorityValues.h"
+
+TEST(StatemachineTest, transitionPriority) {
+	PriorityValues handle;
+	priorityValues_init(&handle);
+	priorityValues_enter(&handle);
+	EXPECT_TRUE(priorityValues_isActive(&handle, PriorityValues_main_region_A));
+	priorityValuesIface_raise_event1(&handle);
+	priorityValues_runCycle(&handle);
+	EXPECT_TRUE(priorityValues_isActive(&handle, PriorityValues_main_region_C));
+}
+TEST(StatemachineTest, regionPriority) {
+	PriorityValues handle;
+	priorityValues_init(&handle);
+	priorityValues_enter(&handle);
+	EXPECT_TRUE(priorityValues_isActive(&handle, PriorityValues_someRegion_A));
+	priorityValuesIface_raise_event2(&handle);
+	priorityValues_runCycle(&handle);
+	EXPECT_TRUE(priorityValues_isActive(&handle, PriorityValues_someRegion_B));
+	EXPECT_TRUE(!priorityValues_isActive(&handle, PriorityValues_main_region_E));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart PriorityValues {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "PriorityValues"
+		}
+	}
+}

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

@@ -0,0 +1,26 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "RaiseEvent.h"
+
+TEST(StatemachineTest, raiseEvent) {
+	RaiseEvent handle;
+	raiseEvent_init(&handle);
+	raiseEvent_enter(&handle);
+	EXPECT_TRUE(raiseEvent_isActive(&handle, RaiseEvent_second_region_SateA));
+	EXPECT_TRUE(raiseEvent_isActive(&handle, RaiseEvent_main_region_StateA));
+	raiseEventIface_raise_e2(&handle);
+	raiseEvent_runCycle(&handle);
+	raiseEvent_runCycle(&handle);
+	EXPECT_TRUE(raiseEvent_isActive(&handle, RaiseEvent_second_region_StateB));
+	EXPECT_TRUE(raiseEvent_isActive(&handle, RaiseEvent_main_region_StateB));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart RaiseEvent {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "RaiseEvent"
+		}
+	}
+}

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

@@ -0,0 +1,479 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "STextKeywordsInStatesAndRegions.h"
+
+TEST(StatemachineTest, activeCheckWithSTextNamedStates) {
+	STextKeywordsInStatesAndRegions handle;
+	sTextKeywordsInStatesAndRegions_init(&handle);
+	sTextKeywordsInStatesAndRegions_enter(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_raise));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_raise));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_raise));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_raise));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_raise));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_raise));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_raise));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_raise));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_raise));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_active));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_interface));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_event));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_in));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_var));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_external));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_default));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_entry));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_always));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_raise));
+	sTextKeywordsInStatesAndRegionsIface_raise_e1(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_valueof));
+	sTextKeywordsInStatesAndRegionsIface_raise_e2(&handle);
+	sTextKeywordsInStatesAndRegions_runCycle(&handle);
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_default_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_operation_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_namespace_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_local_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_interface_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_internal_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_event_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_in_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_out_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_var_valueof));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_readonly_namespace));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_external_internal));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_else_local));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_entry_out));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_exit_readonly));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_always_operation));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_oncycle_else));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_raise_exit));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_valueof_oncycle));
+	EXPECT_TRUE(sTextKeywordsInStatesAndRegions_isActive(&handle, STextKeywordsInStatesAndRegions_active_valueof));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart STextKeywordsInStatesAndRegions {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "STextKeywordsInStatesAndRegions"
+		}
+	}
+}

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

@@ -0,0 +1,28 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "SameNameDifferentRegion.h"
+
+TEST(StatemachineTest, sameNameDifferenRegionTest) {
+	SameNameDifferentRegion handle;
+	sameNameDifferentRegion_init(&handle);
+	sameNameDifferentRegion_enter(&handle);
+	EXPECT_TRUE(sameNameDifferentRegion_isActive(&handle, SameNameDifferentRegion_main_region_StateA));
+	sameNameDifferentRegionIface_raise_e1(&handle);
+	sameNameDifferentRegion_runCycle(&handle);
+	EXPECT_TRUE(sameNameDifferentRegion_isActive(&handle, SameNameDifferentRegion_main_region_StateB));
+	EXPECT_TRUE(sameNameDifferentRegion_isActive(&handle, SameNameDifferentRegion_main_region_StateB_r1_StateA));
+	sameNameDifferentRegionIface_raise_e1(&handle);
+	sameNameDifferentRegion_runCycle(&handle);
+	EXPECT_TRUE(sameNameDifferentRegion_isActive(&handle, SameNameDifferentRegion_main_region_StateB));
+	EXPECT_TRUE(sameNameDifferentRegion_isActive(&handle, SameNameDifferentRegion_main_region_StateB_r1_StateB));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart SameNameDifferentRegion {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "SameNameDifferentRegion"
+		}
+	}
+}

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

@@ -0,0 +1,49 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "ShallowHistory.h"
+
+TEST(StatemachineTest, shallowHistoryTest) {
+	ShallowHistory handle;
+	shallowHistory_init(&handle);
+	shallowHistory_enter(&handle);
+	shallowHistoryIface_raise_event1(&handle);
+	shallowHistory_runCycle(&handle);
+	shallowHistoryIface_raise_event3(&handle);
+	shallowHistory_runCycle(&handle);
+	shallowHistoryIface_raise_event5(&handle);
+	shallowHistory_runCycle(&handle);
+	shallowHistoryIface_raise_event7(&handle);
+	shallowHistory_runCycle(&handle);
+	EXPECT_TRUE(!shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State1));
+	EXPECT_TRUE(shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State2__region0_State4__region0_State7__region0_State9));
+	shallowHistoryIface_raise_event6(&handle);
+	shallowHistory_runCycle(&handle);
+	EXPECT_TRUE(!shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State2__region0_State4__region0_State7__region0_State9));
+	EXPECT_TRUE(shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State2__region0_State4__region0_State6));
+	shallowHistoryIface_raise_event5(&handle);
+	shallowHistory_runCycle(&handle);
+	EXPECT_TRUE(!shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State2__region0_State4__region0_State7__region0_State8));
+	EXPECT_TRUE(shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State2__region0_State4__region0_State7__region0_State9));
+	shallowHistoryIface_raise_event2(&handle);
+	shallowHistory_runCycle(&handle);
+	EXPECT_TRUE(!shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State2__region0_State4__region0_State7__region0_State9));
+	EXPECT_TRUE(shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State1));
+	shallowHistoryIface_raise_event1(&handle);
+	shallowHistory_runCycle(&handle);
+	EXPECT_TRUE(shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State2__region0_State4__region0_State6));
+	EXPECT_TRUE(!shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State1));
+	shallowHistoryIface_raise_event5(&handle);
+	shallowHistory_runCycle(&handle);
+	EXPECT_TRUE(!shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State2__region0_State4__region0_State6));
+	EXPECT_TRUE(shallowHistory_isActive(&handle, ShallowHistory_mainRegion_State2__region0_State4__region0_State7__region0_State9));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart ShallowHistory {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "ShallowHistory"
+		}
+	}
+}

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

@@ -0,0 +1,24 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "SimpleEvent.h"
+
+TEST(StatemachineTest, simpleEventTest) {
+	SimpleEvent handle;
+	simpleEvent_init(&handle);
+	simpleEvent_enter(&handle);
+	EXPECT_TRUE(simpleEvent_isActive(&handle, SimpleEvent_main_region_A));
+	EXPECT_TRUE(5== 5);
+	simpleEventIface_raise_event1(&handle);
+	simpleEvent_runCycle(&handle);
+	EXPECT_TRUE(simpleEvent_isActive(&handle, SimpleEvent_main_region_B));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart SimpleEvent {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "SimpleEvent"
+		}
+	}
+}

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

@@ -0,0 +1,26 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "SimpleHierachy.h"
+
+TEST(StatemachineTest, simpleHierachyTest) {
+	SimpleHierachy handle;
+	simpleHierachy_init(&handle);
+	simpleHierachy_enter(&handle);
+	EXPECT_TRUE(simpleHierachy_isActive(&handle, SimpleHierachy_main_region_A));
+	simpleHierachyIface_raise_event1(&handle);
+	simpleHierachyIface_raise_event1(&handle);
+	simpleHierachyIface_raise_event1(&handle);
+	simpleHierachy_runCycle(&handle);
+	EXPECT_TRUE(simpleHierachy_isActive(&handle, SimpleHierachy_main_region_B));
+	EXPECT_TRUE(simpleHierachy_isActive(&handle, SimpleHierachy_main_region_B_subregion1_B1));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart SimpleHierachy {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "SimpleHierachy"
+		}
+	}
+}

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

@@ -0,0 +1,26 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "StateIsActive.h"
+
+TEST(StatemachineTest, stateIsActive) {
+	StateIsActive handle;
+	stateIsActive_init(&handle);
+	stateIsActive_enter(&handle);
+	EXPECT_TRUE(stateIsActive_isActive(&handle, StateIsActive_R1_R1A));
+	EXPECT_TRUE(stateIsActive_isActive(&handle, StateIsActive_R2_R2A));
+	stateIsActiveIface_raise_event1(&handle);
+	stateIsActive_runCycle(&handle);
+	stateIsActive_runCycle(&handle);
+	EXPECT_TRUE(stateIsActive_isActive(&handle, StateIsActive_R1_R1B));
+	EXPECT_TRUE(stateIsActive_isActive(&handle, StateIsActive_R2_R2B));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart StateIsActive {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "StateIsActive"
+		}
+	}
+}

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

@@ -0,0 +1,22 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "StateWithEmptyRegion.h"
+
+TEST(StatemachineTest, StateWithEmptyRegionTest) {
+	StateWithEmptyRegion handle;
+	stateWithEmptyRegion_init(&handle);
+	stateWithEmptyRegion_enter(&handle);
+	EXPECT_TRUE(stateWithEmptyRegion_isActive(&handle, StateWithEmptyRegion_main_region_A));
+	stateWithEmptyRegion_runCycle(&handle);
+	EXPECT_TRUE(stateWithEmptyRegion_isActive(&handle, StateWithEmptyRegion_main_region_B));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart StateWithEmptyRegion {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "StateWithEmptyRegion"
+		}
+	}
+}

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

@@ -0,0 +1,31 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "StatechartLocalReactions.h"
+
+TEST(StatemachineTest, statechartLocalReactionsTest) {
+	StatechartLocalReactions handle;
+	statechartLocalReactions_init(&handle);
+	statechartLocalReactions_enter(&handle);
+	EXPECT_TRUE(statechartLocalReactions_isActive(&handle, StatechartLocalReactions_main_region_S1));
+	EXPECT_TRUE(statechartLocalReactions_isActive(&handle, StatechartLocalReactions_region2_a));
+	while (statechartLocalReactionsIface_get_myInt(&handle) < 10) {
+		EXPECT_TRUE(statechartLocalReactions_isActive(&handle, StatechartLocalReactions_region2_a));
+		if (statechartLocalReactionsIface_get_myInt(&handle) %2== 0) {
+					EXPECT_TRUE(statechartLocalReactions_isActive(&handle, StatechartLocalReactions_main_region_S1));;
+				  }
+				else {
+					EXPECT_TRUE(statechartLocalReactions_isActive(&handle, StatechartLocalReactions_main_region_S2));;
+				}
+		statechartLocalReactions_runCycle(&handle);
+	}
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart StatechartLocalReactions {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "StatechartLocalReactions"
+		}
+	}
+}

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

@@ -0,0 +1,30 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "StringExpressions.h"
+
+TEST(StatemachineTest, StringExpressionsTest) {
+	StringExpressions handle;
+	stringExpressions_init(&handle);
+	EXPECT_TRUE(strcmp(stringExpressionsIface_get_quotedString(&handle) , "\"x\"") == 0);
+	stringExpressions_enter(&handle);
+	EXPECT_TRUE(stringExpressions_isActive(&handle, StringExpressions_main_region_StateA));
+	EXPECT_TRUE(strcmp(stringExpressionsIface_get_myString(&handle) , "hello") == 0);
+	EXPECT_TRUE(strcmp(stringExpressionsIface_get_myString2(&handle) , "world") == 0);
+	EXPECT_TRUE(strcmp(stringExpressionsIface_get_quotedString(&handle) , "'y'") == 0);
+	stringExpressionsIface_raise_e1(&handle);
+	stringExpressions_runCycle(&handle);
+	EXPECT_TRUE(stringExpressions_isActive(&handle, StringExpressions_main_region_StateB));
+	EXPECT_TRUE(stringExpressionsIface_get_equals(&handle) == false);
+	EXPECT_TRUE(stringExpressionsIface_get_notEqual(&handle) == true);
+	EXPECT_TRUE(strcmp(stringExpressionsIface_get_quotedString(&handle) , "\"z\"") == 0);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart StringExpressions {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "StringExpressions"
+		}
+	}
+}

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

@@ -0,0 +1,38 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "SyncFork.h"
+
+TEST(StatemachineTest, syncForkTest) {
+	SyncFork handle;
+	syncFork_init(&handle);
+	syncFork_enter(&handle);
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_A));
+	syncForkIface_raise_f(&handle);
+	syncFork_runCycle(&handle);
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_B));
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_B_r1_C1));
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_B_r2_D1));
+	syncForkIface_raise_f(&handle);
+	syncFork_runCycle(&handle);
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_B));
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_B_r1_C2));
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_B_r2_D2));
+	syncForkIface_raise_e(&handle);
+	syncFork_runCycle(&handle);
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_A));
+	syncForkIface_raise_f(&handle);
+	syncFork_runCycle(&handle);
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_B));
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_B_r1_C1));
+	EXPECT_TRUE(syncFork_isActive(&handle, SyncFork_main_region_B_r2_D1));
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart SyncFork {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "SyncFork"
+		}
+	}
+}

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

@@ -0,0 +1,97 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "SyncJoin.h"
+
+TEST(StatemachineTest, syncJoin_C2_Waits) {
+	SyncJoin handle;
+	syncJoin_init(&handle);
+	syncJoin_enter(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C1));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D1));
+	syncJoinIface_raise_e(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C2));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D1));
+	syncJoinIface_raise_jc(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C2));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D1));
+	syncJoinIface_raise_jd(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C2));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D1));
+	syncJoinIface_raise_jc(&handle);
+	syncJoinIface_raise_jd(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C2));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D1));
+	syncJoinIface_raise_f(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C2));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D2));
+	syncJoinIface_raise_jc(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C2));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D2));
+	syncJoinIface_raise_jd(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C2));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D2));
+	syncJoinIface_raise_jc(&handle);
+	syncJoinIface_raise_jd(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_A));
+}
+TEST(StatemachineTest, syncJoin_D2_Waits) {
+	SyncJoin handle;
+	syncJoin_init(&handle);
+	syncJoin_enter(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C1));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D1));
+	syncJoinIface_raise_f(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C1));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D2));
+	syncJoinIface_raise_jc(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C1));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D2));
+	syncJoinIface_raise_jd(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C1));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D2));
+	syncJoinIface_raise_jc(&handle);
+	syncJoinIface_raise_jd(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C1));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D2));
+	syncJoinIface_raise_e(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r1_C2));
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_B_r2_D2));
+}
+TEST(StatemachineTest, doubleEntryActionBug) {
+	SyncJoin handle;
+	syncJoin_init(&handle);
+	syncJoin_enter(&handle);
+	syncJoinIface_raise_e(&handle);
+	syncJoinIface_raise_f(&handle);
+	syncJoin_runCycle(&handle);
+	syncJoinIface_raise_jc(&handle);
+	syncJoinIface_raise_jd(&handle);
+	syncJoin_runCycle(&handle);
+	EXPECT_TRUE(syncJoin_isActive(&handle, SyncJoin_main_region_A));
+	EXPECT_TRUE(syncJoinIface_get_x(&handle) == 1);
+}

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

@@ -0,0 +1,8 @@
+GeneratorModel for yakindu::c {
+	statechart SyncJoin {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "SyncJoin"
+		}
+	}
+}

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

@@ -0,0 +1,23 @@
+/**
+* Copyright (c) 2013 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "ValuedEvents.h"
+
+TEST(StatemachineTest, valuedEventsTest) {
+	ValuedEvents handle;
+	valuedEvents_init(&handle);
+	valuedEvents_enter(&handle);
+	valuedEvents_runCycle(&handle);
+	EXPECT_TRUE(valuedEvents_isActive(&handle, ValuedEvents_main_region_A));
+	EXPECT_TRUE(valuedEvents_isActive(&handle, ValuedEvents__region1_C));
+	EXPECT_TRUE(valuedEventsIface_get_myVar(&handle) == 42);
+}

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

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

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

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for AssignmentAsExpression
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class AssignmentAsExpressionTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("AssignmentAsExpression.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void simpleAssignment() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("Add"));
+		assertTrue(getInteger("b") == 5);
+		assertTrue(getInteger("a") == 9);
+		interpreter.runCycle();
+		assertTrue(isActive("Subtract"));
+		assertTrue(getInteger("d") == 6);
+		interpreter.runCycle();
+		assertTrue(isActive("Multiply"));
+		assertTrue(getInteger("e") == 15);
+		interpreter.runCycle();
+		assertTrue(isActive("Divide"));
+		assertTrue(getInteger("g") == 1);
+		interpreter.runCycle();
+		assertTrue(isActive("Modulo"));
+		assertTrue(getInteger("i") == 1);
+		interpreter.runCycle();
+		assertTrue(isActive("Shift"));
+		assertTrue(getInteger("j") == 16);
+		assertTrue(getInteger("k") == 4);
+		interpreter.runCycle();
+		assertTrue(isActive("boolean And"));
+		assertTrue(getInteger("l") == 1);
+		interpreter.runCycle();
+		assertTrue(isActive("boolean Or"));
+		assertTrue(getInteger("p") == 15);
+		interpreter.runCycle();
+		assertTrue(isActive("boolean Xor"));
+		assertTrue(getInteger("u") == 12);
+		interpreter.exit();
+	}
+}

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

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for BitExpressions
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class BitExpressionsTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("BitExpressions.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void BitExpressions() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		assertTrue(getInteger("myBit1") == 5);
+		assertTrue(getInteger("myBit2") == 7);
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		assertTrue(getInteger("leftBitshift") == 10);
+		assertTrue(getInteger("rightBitshift") == 2);
+		assertTrue(getInteger("complementBitshift") == -6);
+		assertTrue(getInteger("bitwiseAnd") == 5);
+		assertTrue(getInteger("bitwiseOr") == 7);
+		assertTrue(getInteger("bitwiseXor") == 2);
+	}
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for BooleanExpressions
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class BooleanExpressionsTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("BooleanExpressions.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void booleanExpressions() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		assertTrue(getBoolean("myBool1") == true);
+		assertTrue(getBoolean("myBool2") == false);
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("StateB"));
+		assertTrue(getBoolean("and") == false);
+		assertTrue(getBoolean("or") == true);
+		assertTrue(getBoolean("not") == false);
+		assertTrue(getBoolean("equal") == false);
+		assertTrue(getBoolean("notequal") == true);
+	}
+}

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

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

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

@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for Choice
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class ChoiceTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models.loadExecutionFlowFromResource("Choice.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void elseChoiceUsingNonDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", true);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+	}
+	@Test
+	public void elseChoiceUsingDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", false);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+	}
+	@Test
+	public void defaultChoiceUsingNonDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", true);
+		raiseEvent("g");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+	}
+	@Test
+	public void defaultChoiceUsingDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", false);
+		raiseEvent("g");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+	}
+	@Test
+	public void uncheckedChoiceUsingNonDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", true);
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("C"));
+	}
+	@Test
+	public void uncheckedChoiceUsingDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", false);
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+	}
+	@Test
+	public void alwaysTrueTransitionInChoice() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("c", true);
+		raiseEvent("h");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+	}
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for ExitState
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class ExitStateTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("ExitState.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void defaultExit() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("E"));
+	}
+	@Test
+	public void namedExitThroughNamedTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("f");
+		interpreter.runCycle();
+		assertTrue(isActive("F"));
+	}
+	@Test
+	public void namedExitThroughDefaultTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("g");
+		interpreter.runCycle();
+		assertTrue(isActive("E"));
+	}
+	@Test
+	public void remainInA() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+	}
+}

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

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

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

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

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

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for GuardedEntry
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class GuardedEntryTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("GuardedEntry.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void EntryNotTakenOnStatechartEnter() throws Exception {
+		assertTrue(getBoolean("guard") == false);
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(getBoolean("done") == false);
+	}
+	@Test
+	public void EntryTakenOnStatechartEnter() throws Exception {
+		setBoolean("guard", true);
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(getBoolean("done") == true);
+	}
+	@Test
+	public void EntryTakenInTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		setBoolean("guard", true);
+		setBoolean("done", false);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(getBoolean("done"));
+	}
+	@Test
+	public void EntryNotTakenInTransition() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		setBoolean("guard", false);
+		setBoolean("done", false);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("A"));
+		assertTrue(!getBoolean("done"));
+	}
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for GuardedExit
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class GuardedExitTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("GuardedExit.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void ExitTaken() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		assertTrue(!getBoolean("guard"));
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(!getBoolean("done"));
+	}
+	@Test
+	public void ExitNotTaken() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		setBoolean("guard", true);
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isActive("B"));
+		assertTrue(getBoolean("done"));
+	}
+}

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

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

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

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

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

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for IntegerExpressions
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class IntegerExpressionsTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("IntegerExpressions.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void integerExpressions() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("StateA"));
+		assertTrue(getInteger("myInt1") == 10);
+		assertTrue(getInteger("myInt2") == 5);
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(getBoolean("less") == false);
+		assertTrue(getBoolean("greater") == true);
+		assertTrue(getBoolean("equalOrLess") == false);
+		assertTrue(getBoolean("equalOrGreater") == true);
+		assertTrue(getBoolean("equal") == false);
+		assertTrue(getBoolean("notEqual") == true);
+		assertTrue(getInteger("plus") == 15);
+		assertTrue(getInteger("minus") == 5);
+		assertTrue(getInteger("multiply") == 50);
+		assertTrue(getInteger("division") == 2);
+		assertTrue(getInteger("modulo") == 0);
+		assertTrue(getInteger("negat") == -10);
+		assertTrue(getInteger("multiAssign") == 20);
+		assertTrue(getInteger("divAssign") == 2);
+		assertTrue(getInteger("plusAssign") == 12);
+		assertTrue(getInteger("minusAssign") == -8);
+		assertTrue(getInteger("moduloAssign") == 0);
+	}
+}

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

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

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

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

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

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for OutEventLifeCycle
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class OutEventLifeCycleTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("OutEventLifeCycle.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void availableAfterCycle() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(isRaised("f"));
+	}
+	@Test
+	public void availableWithinCycle() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		interpreter.runCycle();
+		assertTrue(getBoolean("f_available_in_cycle"));
+	}
+	@Test
+	public void unvailableWithin2ndCycle() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		interpreter.runCycle();
+		interpreter.runCycle();
+		assertTrue(!getBoolean("f_available_in_next_cycle"));
+	}
+	@Test
+	public void unvailableAfter2ndCycle() throws Exception {
+		interpreter.enter();
+		raiseEvent("e");
+		interpreter.runCycle();
+		interpreter.runCycle();
+		assertTrue(!isRaised("f"));
+	}
+}

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

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

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

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for PerformanceTest
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class PerformanceTestsTest extends AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("PerformanceTest.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void test_100_000() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		while (getInteger("c") < 100000) {
+			if (isActive("A")) {
+				raiseEvent("e1");;
+			} else {
+				if (getInteger("c") % 2 == 0) {
+					raiseEvent("e2");;
+				} else {
+					raiseEvent("e3");;
+				};
+			}
+			interpreter.runCycle();
+		}
+		assertTrue(getInteger("a") > 2);
+	}
+	@Test
+	public void test_1_000_000() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		while (getInteger("c") < 1000000) {
+			if (isActive("A")) {
+				raiseEvent("e1");;
+			} else {
+				if (getInteger("c") % 2 == 0) {
+					raiseEvent("e2");;
+				} else {
+					raiseEvent("e3");;
+				};
+			}
+			interpreter.runCycle();
+		}
+		assertTrue(getInteger("a") > 2);
+	}
+	@Test
+	public void test_10_000_000() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("A"));
+		while (getInteger("c") < 10000000) {
+			if (isActive("A")) {
+				raiseEvent("e1");;
+			} else {
+				if (getInteger("c") % 2 == 0) {
+					raiseEvent("e2");;
+				} else {
+					raiseEvent("e3");;
+				};
+			}
+			interpreter.runCycle();
+		}
+		assertTrue(getInteger("a") > 2);
+	}
+}

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

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

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

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

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

@@ -0,0 +1,507 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.model.sexec.interpreter.test;
+import org.eclipse.xtext.junit4.InjectWith;
+import org.eclipse.xtext.junit4.XtextRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.model.sexec.interpreter.test.util.AbstractExecutionFlowTest;
+import org.yakindu.sct.model.sexec.interpreter.test.util.SExecInjectionProvider;
+import com.google.inject.Inject;
+import org.junit.Before;
+import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.test.models.SCTUnitTestModels;
+import static junit.framework.Assert.*;
+/**
+ *  Unit TestCase for STextKeywordsInStatesAndRegions
+ */
+@SuppressWarnings("all")
+@RunWith(XtextRunner.class)
+@InjectWith(SExecInjectionProvider.class)
+public class STextKeywordsInStatesAndRegionsTest
+		extends
+			AbstractExecutionFlowTest {
+
+	@Inject
+	private SCTUnitTestModels models;
+
+	@Before
+	public void setup() throws Exception {
+		ExecutionFlow flow = models
+				.loadExecutionFlowFromResource("STextKeywordsInStatesAndRegions.sct");
+		initInterpreter(flow);
+	}
+	@Test
+	public void activeCheckWithSTextNamedStates() throws Exception {
+		interpreter.enter();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("raise"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("active"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("interface"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("event"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("in"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("var"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("external"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("default"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("entry"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("always"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("raise"));
+		raiseEvent("e1");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		raiseEvent("e2");
+		interpreter.runCycle();
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+		assertTrue(isActive("namespace"));
+		assertTrue(isActive("internal"));
+		assertTrue(isActive("local"));
+		assertTrue(isActive("out"));
+		assertTrue(isActive("readonly"));
+		assertTrue(isActive("operation"));
+		assertTrue(isActive("else"));
+		assertTrue(isActive("exit"));
+		assertTrue(isActive("oncycle"));
+		assertTrue(isActive("valueof"));
+	}
+}