Newly generated cpp files for the sctunit tests (#1848)

* Newly generated cpp files for the sctunit tests

Newly generated the cpp files for the sctunit tests due to some
generator changes in the pro repository

* Generated again

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

@@ -4,16 +4,17 @@
 #include "AlwaysOncycle.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static AlwaysOncycle* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class AlwaysOncycleTest : public ::testing::Test{
 	protected:
+	
+	AlwaysOncycle* statechart;
+	
 	virtual void SetUp() {
 		statechart = new AlwaysOncycle();
 		statechart->init();
@@ -27,31 +28,33 @@ class AlwaysOncycleTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(AlwaysOncycleTest, alwaysOnCycleTest) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(AlwaysOncycle::main_region_StateA));
 	
-	while (statechart->getDefaultSCI()->get_value()< 5l) {
-		runner->proceed_cycles(1);
+};
+
+	TEST_F(AlwaysOncycleTest, alwaysOnCycleTest) {
+		
+		statechart->enter();
+		
 		EXPECT_TRUE(statechart->isStateActive(AlwaysOncycle::main_region_StateA));
-	}
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AlwaysOncycle::main_region_StateB));
-	
-	while (statechart->getDefaultSCI()->get_value()< 5l) {
+		
+		while (statechart->getDefaultSCI()->get_value()< 5l) {
+			runner->proceed_cycles(1);
+			EXPECT_TRUE(statechart->isStateActive(AlwaysOncycle::main_region_StateA));
+		}
+		
 		runner->proceed_cycles(1);
+		
 		EXPECT_TRUE(statechart->isStateActive(AlwaysOncycle::main_region_StateB));
-	}
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AlwaysOncycle::main_region_StateA));
-	
+		
+		while (statechart->getDefaultSCI()->get_value()< 5l) {
+			runner->proceed_cycles(1);
+			EXPECT_TRUE(statechart->isStateActive(AlwaysOncycle::main_region_StateB));
+		}
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(AlwaysOncycle::main_region_StateA));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "AssignmentAsExpression.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static AssignmentAsExpression* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class AssignmentAsExpressionTest : public ::testing::Test{
 	protected:
+	
+	AssignmentAsExpression* statechart;
+	
 	virtual void SetUp() {
 		statechart = new AssignmentAsExpression();
 		statechart->init();
@@ -27,69 +28,71 @@ class AssignmentAsExpressionTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(AssignmentAsExpressionTest, simpleAssignment) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Add));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_b()== 5l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a()== 9l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Subtract));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_d()== 6l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Multiply));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_e()== 15l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Divide));
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_g()== 1l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Modulo));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_i()== 1l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Shift));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_j()== 16l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_k()== 4l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_boolean_And));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_l()== 1l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_boolean_Or));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_p()== 15l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_boolean_Xor));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_u()== 12l);
-	
-	statechart->exit();
 	
+};
+
+	TEST_F(AssignmentAsExpressionTest, simpleAssignment) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Add));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_b()== 5l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a()== 9l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Subtract));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_d()== 6l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Multiply));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_e()== 15l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Divide));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_g()== 1l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Modulo));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_i()== 1l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_Shift));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_j()== 16l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_k()== 4l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_boolean_And));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_l()== 1l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_boolean_Or));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_p()== 15l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(AssignmentAsExpression::main_region_boolean_Xor));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_u()== 12l);
+		
+		statechart->exit();
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "BitExpressions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static BitExpressions* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class BitExpressionsTest : public ::testing::Test{
 	protected:
+	
+	BitExpressions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new BitExpressions();
 		statechart->init();
@@ -27,35 +28,37 @@ class BitExpressionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(BitExpressionsTest, BitExpressions) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(BitExpressions::main_region_StateA));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myBit1()== 5l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myBit2()== 7l);
 	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(BitExpressions::main_region_StateB));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_leftBitshift()== 10l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_rightBitshift()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_complementBitshift()== - 6l );
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_bitwiseAnd()== 5l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_bitwiseOr()== 7l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_bitwiseXor()== 2l);
 	
+};
+
+	TEST_F(BitExpressionsTest, BitExpressions) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(BitExpressions::main_region_StateA));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myBit1()== 5l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myBit2()== 7l);
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(BitExpressions::main_region_StateB));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_leftBitshift()== 10l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_rightBitshift()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_complementBitshift()== - 6l );
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_bitwiseAnd()== 5l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_bitwiseOr()== 7l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_bitwiseXor()== 2l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "BooleanExpressions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static BooleanExpressions* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class BooleanExpressionsTest : public ::testing::Test{
 	protected:
+	
+	BooleanExpressions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new BooleanExpressions();
 		statechart->init();
@@ -27,33 +28,35 @@ class BooleanExpressionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(BooleanExpressionsTest, booleanExpressions) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(BooleanExpressions::main_region_StateA));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool1()== true);
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool2()== false);
-	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(BooleanExpressions::main_region_StateB));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_and()== false);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_or()== true);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_not()== false);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_equal()== false);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_notequal()== true);
 	
+};
+
+	TEST_F(BooleanExpressionsTest, booleanExpressions) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(BooleanExpressions::main_region_StateA));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool1()== true);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool2()== false);
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(BooleanExpressions::main_region_StateB));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_and()== false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_or()== true);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_not()== false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_equal()== false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_notequal()== true);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "CKeywords.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static CKeywords* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class CKeywordsTest : public ::testing::Test{
 	protected:
+	
+	CKeywords* statechart;
+	
 	virtual void SetUp() {
 		statechart = new CKeywords();
 		statechart->init();
@@ -27,23 +28,25 @@ class CKeywordsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(CKeywordsTest, CKeywordsTest) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(CKeywords::auto_char));
-	
-	statechart->getDefaultSCI()->raise_auto();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(CKeywords::auto_loop));
-	
-	EXPECT_TRUE(statechart->isStateActive(CKeywords::auto_loop_switch_case));
-	
-	EXPECT_TRUE(statechart->isStateActive(CKeywords::auto_loop_switch_case_enum_asm));
 	
+};
+
+	TEST_F(CKeywordsTest, CKeywordsTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(CKeywords::auto_char));
+		
+		statechart->getDefaultSCI()->raise_auto();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(CKeywords::auto_loop));
+		
+		EXPECT_TRUE(statechart->isStateActive(CKeywords::auto_loop_switch_case));
+		
+		EXPECT_TRUE(statechart->isStateActive(CKeywords::auto_loop_switch_case_enum_asm));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "CastExpressions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static CastExpressions* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class CastExpressionsTest : public ::testing::Test{
 	protected:
+	
+	CastExpressions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new CastExpressions();
 		statechart->init();
@@ -27,25 +28,27 @@ class CastExpressionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(CastExpressionsTest, CastExpressionTest) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_realValue()== 5l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_intValue()== 5l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_realValue()== 15l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(CastExpressions::main_region_C));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_realValue()== 757l);
 	
+};
+
+	TEST_F(CastExpressionsTest, CastExpressionTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_realValue()== 5l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_intValue()== 5l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_realValue()== 15l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(CastExpressions::main_region_C));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_realValue()== 757l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ChildFirstExecutionHierarchy.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ChildFirstExecutionHierarchy* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ChildFirstExecutionHierarchyTest : public ::testing::Test{
 	protected:
+	
+	ChildFirstExecutionHierarchy* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ChildFirstExecutionHierarchy();
 		statechart->init();
@@ -27,109 +28,115 @@ class ChildFirstExecutionHierarchyTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-void assertNoLocalReaction(){
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_local());
 	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_local());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_local());
+	virtual void assertNoLocalReaction() {
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_local());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_local());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_local());
+		
+		
+	}
 	
-}
+};
 
-TEST_F(ChildFirstExecutionHierarchyTest, childShouldTakeTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_B));
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_reacted());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_reacted());
-	
-	assertNoLocalReaction();
-	
+	TEST_F(ChildFirstExecutionHierarchyTest, childShouldTakeTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_B));
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_reacted());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_reacted());
+		
+		assertNoLocalReaction();
+		
+		
 }
-TEST_F(ChildFirstExecutionHierarchyTest, parentShouldTakeTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->set_disable_aaa(true);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_B));
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_reacted());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_local());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_local());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local());
-	
+	TEST_F(ChildFirstExecutionHierarchyTest, parentShouldTakeTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->set_disable_aaa(true);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_B));
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_reacted());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_local());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_local());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local());
+		
+		
 }
-TEST_F(ChildFirstExecutionHierarchyTest, grandparentShouldTakeTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->set_disable_aa(true);
-	
-	statechart->getDefaultSCI()->set_disable_aaa(true);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_B));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_local());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local());
-	
+	TEST_F(ChildFirstExecutionHierarchyTest, grandparentShouldTakeTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->set_disable_aa(true);
+		
+		statechart->getDefaultSCI()->set_disable_aaa(true);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_B));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_local());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local());
+		
+		
 }
-TEST_F(ChildFirstExecutionHierarchyTest, expectLocalReactrionsExecuteWithNoTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local());
-	
+	TEST_F(ChildFirstExecutionHierarchyTest, expectLocalReactrionsExecuteWithNoTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstExecutionHierarchy::ChildFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local());
+		
+		
 }

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

@@ -4,17 +4,18 @@
 #include "ChildFirstLocalReactions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
-static long counter = 0l;
-
-
-static ChildFirstLocalReactions* statechart;
+long counter = 0l;
 
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ChildFirstLocalReactionsTest : public ::testing::Test{
 	protected:
+	
+	ChildFirstLocalReactions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ChildFirstLocalReactions();
 		statechart->init();
@@ -28,94 +29,99 @@ class ChildFirstLocalReactionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ChildFirstLocalReactionsTest, expectBottomUpLocalReactionOrder) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 2l);
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 3l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 4l);
 	
+};
+
+	TEST_F(ChildFirstLocalReactionsTest, expectBottomUpLocalReactionOrder) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 3l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 4l);
+		
+		
 }
-TEST_F(ChildFirstLocalReactionsTest, expectParentLocalReactionOnChildLocalTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAB));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 3l);
-	
+	TEST_F(ChildFirstLocalReactionsTest, expectParentLocalReactionOnChildLocalTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAB));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 3l);
+		
+		
 }
-TEST_F(ChildFirstLocalReactionsTest, expectGrandparentLocalReactionOnParentLocalTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->set_disable_aaa(true);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AB));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 3l);
-	
+	TEST_F(ChildFirstLocalReactionsTest, expectGrandparentLocalReactionOnParentLocalTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->set_disable_aaa(true);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AB));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 3l);
+		
+		
 }
-TEST_F(ChildFirstLocalReactionsTest, expectNoLocalReactionOnGrandparentTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->set_disable_aaa(true);
-	
-	statechart->getDefaultSCI()->set_disable_aa(true);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_B));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 3l);
-	
+	TEST_F(ChildFirstLocalReactionsTest, expectNoLocalReactionOnGrandparentTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->set_disable_aaa(true);
+		
+		statechart->getDefaultSCI()->set_disable_aa(true);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ChildFirstLocalReactions::ChildFirstLocalReactions_r_B));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 3l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "Choice.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static Choice* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ChoiceTest : public ::testing::Test{
 	protected:
+	
+	Choice* statechart;
+	
 	virtual void SetUp() {
 		statechart = new Choice();
 		statechart->init();
@@ -27,107 +28,119 @@ class ChoiceTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-void initForEventE(bool valueForC){
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_A));
-	
-	statechart->getDefaultSCI()->set_c(valueForC);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-}
-void initForEventF(bool valueForC){
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_A));
-	
-	statechart->getDefaultSCI()->set_c(valueForC);
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-}
-void initForEventG(bool valueForC){
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_A));
-	
-	statechart->getDefaultSCI()->set_c(valueForC);
-	
-	statechart->getDefaultSCI()->raise_g();
-	
-	runner->proceed_cycles(1);
-	
-}
-void initForEventH(bool valueForC){
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_A));
 	
-	statechart->getDefaultSCI()->set_c(valueForC);
-	
-	statechart->getDefaultSCI()->raise_h();
-	
-	runner->proceed_cycles(1);
+	virtual void initForEventE(bool valueForC) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_A));
+		
+		statechart->getDefaultSCI()->set_c(valueForC);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		
+	}
+	virtual void initForEventF(bool valueForC) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_A));
+		
+		statechart->getDefaultSCI()->set_c(valueForC);
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		
+	}
+	virtual void initForEventG(bool valueForC) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_A));
+		
+		statechart->getDefaultSCI()->set_c(valueForC);
+		
+		statechart->getDefaultSCI()->raise_g();
+		
+		runner->proceed_cycles(1);
+		
+		
+	}
+	virtual void initForEventH(bool valueForC) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_A));
+		
+		statechart->getDefaultSCI()->set_c(valueForC);
+		
+		statechart->getDefaultSCI()->raise_h();
+		
+		runner->proceed_cycles(1);
+		
+		
+	}
 	
-}
+};
 
-TEST_F(ChoiceTest, elseChoiceUsingNonDefaultTransition) {
-	
-	initForEventE(true);
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_C));
-	
+	TEST_F(ChoiceTest, elseChoiceUsingNonDefaultTransition) {
+		
+		initForEventE(true);
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_C));
+		
+		
 }
-TEST_F(ChoiceTest, elseChoiceUsingDefaultTransition) {
-	
-	initForEventE(false);
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_B));
-	
+	TEST_F(ChoiceTest, elseChoiceUsingDefaultTransition) {
+		
+		initForEventE(false);
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_B));
+		
+		
 }
-TEST_F(ChoiceTest, defaultChoiceUsingNonDefaultTransition) {
-	
-	initForEventG(true);
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_C));
-	
+	TEST_F(ChoiceTest, defaultChoiceUsingNonDefaultTransition) {
+		
+		initForEventG(true);
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_C));
+		
+		
 }
-TEST_F(ChoiceTest, defaultChoiceUsingDefaultTransition) {
-	
-	initForEventG(false);
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_B));
-	
+	TEST_F(ChoiceTest, defaultChoiceUsingDefaultTransition) {
+		
+		initForEventG(false);
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_B));
+		
+		
 }
-TEST_F(ChoiceTest, uncheckedChoiceUsingNonDefaultTransition) {
-	
-	initForEventF(true);
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_C));
-	
+	TEST_F(ChoiceTest, uncheckedChoiceUsingNonDefaultTransition) {
+		
+		initForEventF(true);
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_C));
+		
+		
 }
-TEST_F(ChoiceTest, uncheckedChoiceUsingDefaultTransition) {
-	
-	initForEventF(false);
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_B));
-	
+	TEST_F(ChoiceTest, uncheckedChoiceUsingDefaultTransition) {
+		
+		initForEventF(false);
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_B));
+		
+		
 }
-TEST_F(ChoiceTest, alwaysTrueTransitionInChoice) {
-	
-	initForEventH(true);
-	
-	EXPECT_TRUE(statechart->isStateActive(Choice::main_region_C));
-	
+	TEST_F(ChoiceTest, alwaysTrueTransitionInChoice) {
+		
+		initForEventH(true);
+		
+		EXPECT_TRUE(statechart->isStateActive(Choice::main_region_C));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ConditionalExpressions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ConditionalExpressions* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ConditionalExpression : public ::testing::Test{
 	protected:
+	
+	ConditionalExpressions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ConditionalExpressions();
 		statechart->init();
@@ -27,23 +28,25 @@ class ConditionalExpression : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ConditionalExpression, ConditionalExpressionTest) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(ConditionalExpressions::main_region_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_condition()== 1l);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ConditionalExpressions::main_region_B));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_condition()== 2l);
 	
+};
+
+	TEST_F(ConditionalExpression, ConditionalExpressionTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ConditionalExpressions::main_region_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_condition()== 1l);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ConditionalExpressions::main_region_B));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_condition()== 2l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ConstOnlyDefaultScope.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ConstOnlyDefaultScope* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ConstOnlyDefaultScopeTest : public ::testing::Test{
 	protected:
+	
+	ConstOnlyDefaultScope* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ConstOnlyDefaultScope();
 		statechart->init();
@@ -27,24 +28,27 @@ class ConstOnlyDefaultScopeTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ConstOnlyDefaultScopeTest, statechartEntry) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(ConstOnlyDefaultScope::ConstOnlyDefaultScope_main_region_A));
 	
+};
+
+	TEST_F(ConstOnlyDefaultScopeTest, statechartEntry) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ConstOnlyDefaultScope::ConstOnlyDefaultScope_main_region_A));
+		
+		
 }
-TEST_F(ConstOnlyDefaultScopeTest, stateTransition) {
-	
-	statechart->enter();
-	
-	statechart->getSCI_A()->raise_e(1l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ConstOnlyDefaultScope::ConstOnlyDefaultScope_main_region_B));
-	
+	TEST_F(ConstOnlyDefaultScopeTest, stateTransition) {
+		
+		statechart->enter();
+		
+		statechart->getSCI_A()->raise_e(1l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ConstOnlyDefaultScope::ConstOnlyDefaultScope_main_region_B));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ConstOnlyInternalScope.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ConstOnlyInternalScope* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ConstOnlyInternalScopeTest : public ::testing::Test{
 	protected:
+	
+	ConstOnlyInternalScope* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ConstOnlyInternalScope();
 		statechart->init();
@@ -27,24 +28,27 @@ class ConstOnlyInternalScopeTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ConstOnlyInternalScopeTest, statechartEntry) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(ConstOnlyInternalScope::ConstOnlyInternalScope_main_region_A));
 	
+};
+
+	TEST_F(ConstOnlyInternalScopeTest, statechartEntry) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ConstOnlyInternalScope::ConstOnlyInternalScope_main_region_A));
+		
+		
 }
-TEST_F(ConstOnlyInternalScopeTest, stateTransition) {
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->raise_e( 1l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ConstOnlyInternalScope::ConstOnlyInternalScope_main_region_B));
-	
+	TEST_F(ConstOnlyInternalScopeTest, stateTransition) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->raise_e( 1l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ConstOnlyInternalScope::ConstOnlyInternalScope_main_region_B));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ConstOnlyNamedScope.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ConstOnlyNamedScope* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ConstOnlyNamedScopeTest : public ::testing::Test{
 	protected:
+	
+	ConstOnlyNamedScope* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ConstOnlyNamedScope();
 		statechart->init();
@@ -27,24 +28,27 @@ class ConstOnlyNamedScopeTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ConstOnlyNamedScopeTest, statechartEntry) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(ConstOnlyNamedScope::ConstOnlyNamedScope_main_region_A));
 	
+};
+
+	TEST_F(ConstOnlyNamedScopeTest, statechartEntry) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ConstOnlyNamedScope::ConstOnlyNamedScope_main_region_A));
+		
+		
 }
-TEST_F(ConstOnlyNamedScopeTest, stateTransition) {
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->raise_e( 1l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ConstOnlyNamedScope::ConstOnlyNamedScope_main_region_B));
-	
+	TEST_F(ConstOnlyNamedScopeTest, stateTransition) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->raise_e( 1l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ConstOnlyNamedScope::ConstOnlyNamedScope_main_region_B));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "Constants.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static Constants* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ConstantsTests : public ::testing::Test{
 	protected:
+	
+	Constants* statechart;
+	
 	virtual void SetUp() {
 		statechart = new Constants();
 		statechart->init();
@@ -27,41 +28,43 @@ class ConstantsTests : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ConstantsTests, constantDefinition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(Constants::main_region_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 10l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_y()== 20l);
-	
-	EXPECT_TRUE(strcmp(statechart->getSCI_Named()->get_y(), "Hello World") == 0);
 	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_result()== 20l);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Constants::main_region_C));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_result()== 100l);
-	
-	statechart->getDefaultSCI()->raise_e2( statechart->getDefaultSCI()->get_x());
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_result()== 1000l);
-	
-	EXPECT_TRUE(statechart->isStateActive(Constants::main_region_A));
 	
+};
+
+	TEST_F(ConstantsTests, constantDefinition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(Constants::main_region_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 10l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_y()== 20l);
+		
+		EXPECT_TRUE(strcmp(statechart->getSCI_Named()->get_y(), "Hello World") == 0);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_result()== 20l);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Constants::main_region_C));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_result()== 100l);
+		
+		statechart->getDefaultSCI()->raise_e2( statechart->getDefaultSCI()->get_x());
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_result()== 1000l);
+		
+		EXPECT_TRUE(statechart->isStateActive(Constants::main_region_A));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "Declarations.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static Declarations* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class DeclarationsTest : public ::testing::Test{
 	protected:
+	
+	Declarations* statechart;
+	
 	virtual void SetUp() {
 		statechart = new Declarations();
 		statechart->init();
@@ -27,11 +28,13 @@ class DeclarationsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(DeclarationsTest, declarationsTest) {
 	
-	statechart->enter();
 	
+};
+
+	TEST_F(DeclarationsTest, declarationsTest) {
+		
+		statechart->enter();
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "DeepEntry.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static DeepEntry* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class DeepEntryTest : public ::testing::Test{
 	protected:
+	
+	DeepEntry* statechart;
+	
 	virtual void SetUp() {
 		statechart = new DeepEntry();
 		statechart->init();
@@ -27,17 +28,19 @@ class DeepEntryTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(DeepEntryTest, enterToSubstate) {
-	
-	statechart->enter();
-	
-	long vergleich = 4l;
 	
-	EXPECT_TRUE(vergleich== 4l);
-	
-	statechart->exit();
 	
+};
+
+	TEST_F(DeepEntryTest, enterToSubstate) {
+		
+		statechart->enter();
+		
+		long vergleich = 4l;
+		
+		EXPECT_TRUE(vergleich== 4l);
+		
+		statechart->exit();
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "DeepHistory.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static DeepHistory* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class DeepHistoryTest : public ::testing::Test{
 	protected:
+	
+	DeepHistory* statechart;
+	
 	virtual void SetUp() {
 		statechart = new DeepHistory();
 		statechart->init();
@@ -27,47 +28,49 @@ class DeepHistoryTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(DeepHistoryTest, deepHistoryTest) {
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	runner->proceed_cycles(1);
-	
-	statechart->getDefaultSCI()->raise_event3();
-	
-	runner->proceed_cycles(1);
-	
-	statechart->getDefaultSCI()->raise_event5();
-	
-	runner->proceed_cycles(1);
 	
-	statechart->getDefaultSCI()->raise_event7();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->isStateActive(DeepHistory::mainRegion_State1));
-	
-	EXPECT_TRUE(statechart->isStateActive(DeepHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
-	
-	statechart->getDefaultSCI()->raise_event2();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(DeepHistory::mainRegion_State1));
-	
-	EXPECT_TRUE(!statechart->isStateActive(DeepHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->isStateActive(DeepHistory::mainRegion_State1));
-	
-	EXPECT_TRUE(statechart->isStateActive(DeepHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
 	
+};
+
+	TEST_F(DeepHistoryTest, deepHistoryTest) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getDefaultSCI()->raise_event3();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getDefaultSCI()->raise_event5();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getDefaultSCI()->raise_event7();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->isStateActive(DeepHistory::mainRegion_State1));
+		
+		EXPECT_TRUE(statechart->isStateActive(DeepHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		
+		statechart->getDefaultSCI()->raise_event2();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(DeepHistory::mainRegion_State1));
+		
+		EXPECT_TRUE(!statechart->isStateActive(DeepHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->isStateActive(DeepHistory::mainRegion_State1));
+		
+		EXPECT_TRUE(statechart->isStateActive(DeepHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "DynamicChoice.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static DynamicChoice* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class DynamicChoiceTest : public ::testing::Test{
 	protected:
+	
+	DynamicChoice* statechart;
+	
 	virtual void SetUp() {
 		statechart = new DynamicChoice();
 		statechart->init();
@@ -27,17 +28,19 @@ class DynamicChoiceTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(DynamicChoiceTest, DynamicChoiceTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(DynamicChoice::main_region_Start));
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(DynamicChoice::main_region_A));
 	
+};
+
+	TEST_F(DynamicChoiceTest, DynamicChoiceTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(DynamicChoice::main_region_Start));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(DynamicChoice::main_region_A));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "EmptyTransition.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static EmptyTransition* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class EmptyTransitionTest : public ::testing::Test{
 	protected:
+	
+	EmptyTransition* statechart;
+	
 	virtual void SetUp() {
 		statechart = new EmptyTransition();
 		statechart->init();
@@ -27,17 +28,19 @@ class EmptyTransitionTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(EmptyTransitionTest, EmptyTransitionTest) {
-	
-	statechart->enter();
-	
-	runner->proceed_cycles(1);
 	
-	EXPECT_TRUE(!statechart->isStateActive(EmptyTransition::main_region_B));
-	
-	EXPECT_TRUE(statechart->isStateActive(EmptyTransition::main_region_A));
 	
+};
+
+	TEST_F(EmptyTransitionTest, EmptyTransitionTest) {
+		
+		statechart->enter();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->isStateActive(EmptyTransition::main_region_B));
+		
+		EXPECT_TRUE(statechart->isStateActive(EmptyTransition::main_region_A));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "EnterState.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static EnterState* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class EnterStateTest : public ::testing::Test{
 	protected:
+	
+	EnterState* statechart;
+	
 	virtual void SetUp() {
 		statechart = new EnterState();
 		statechart->init();
@@ -27,45 +28,49 @@ class EnterStateTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(EnterStateTest, defaultEntry) {
 	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(EnterState::r_A));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(EnterState::r_B_r_E));
 	
+};
+
+	TEST_F(EnterStateTest, defaultEntry) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(EnterState::r_A));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(EnterState::r_B_r_E));
+		
+		
 }
-TEST_F(EnterStateTest, namedEntryThroughNamedTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(EnterState::r_A));
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(EnterState::r_B_r_F));
-	
+	TEST_F(EnterStateTest, namedEntryThroughNamedTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(EnterState::r_A));
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(EnterState::r_B_r_F));
+		
+		
 }
-TEST_F(EnterStateTest, namedEntryThroughDefaultTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(EnterState::r_A));
-	
-	statechart->getDefaultSCI()->raise_g();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(EnterState::r_B_r_E));
-	
+	TEST_F(EnterStateTest, namedEntryThroughDefaultTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(EnterState::r_A));
+		
+		statechart->getDefaultSCI()->raise_g();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(EnterState::r_B_r_E));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "EntryChoice.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static EntryChoice* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class EntryChoiceTest : public ::testing::Test{
 	protected:
+	
+	EntryChoice* statechart;
+	
 	virtual void SetUp() {
 		statechart = new EntryChoice();
 		statechart->init();
@@ -27,17 +28,19 @@ class EntryChoiceTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(EntryChoiceTest, EntryChoiceTest) {
-	
-	statechart->enter();
-	
-	runner->proceed_cycles(1);
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(EntryChoice::main_region_A));
 	
+};
+
+	TEST_F(EntryChoiceTest, EntryChoiceTest) {
+		
+		statechart->enter();
+		
+		runner->proceed_cycles(1);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(EntryChoice::main_region_A));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "EntryExitSelfTransition.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static EntryExitSelfTransition* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class EntryExitSelfTransitionTest : public ::testing::Test{
 	protected:
+	
+	EntryExitSelfTransition* statechart;
+	
 	virtual void SetUp() {
 		statechart = new EntryExitSelfTransition();
 		statechart->init();
@@ -27,63 +28,67 @@ class EntryExitSelfTransitionTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-void init(){
-	
-	statechart->enter();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_entries()== 1l);
 	
-	EXPECT_TRUE(statechart->isStateActive(EntryExitSelfTransition::main_region_A__region0_B));
-	
-	statechart->getDefaultSCI()->set_entries(0l);
+	virtual void init() {
+		
+		statechart->enter();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_entries()== 1l);
+		
+		EXPECT_TRUE(statechart->isStateActive(EntryExitSelfTransition::main_region_A__region0_B));
+		
+		statechart->getDefaultSCI()->set_entries(0l);
+		
+		
+	}
 	
-}
+};
 
-TEST_F(EntryExitSelfTransitionTest, SelfTransitionToChildState) {
-	
-	init();
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_entries()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_exits()== 1l);
-	
-	EXPECT_TRUE(statechart->isStateActive(EntryExitSelfTransition::main_region_A__region0_C));
-	
-	statechart->exit();
-	
+	TEST_F(EntryExitSelfTransitionTest, SelfTransitionToChildState) {
+		
+		init();
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_entries()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_exits()== 1l);
+		
+		EXPECT_TRUE(statechart->isStateActive(EntryExitSelfTransition::main_region_A__region0_C));
+		
+		statechart->exit();
+		
+		
 }
-TEST_F(EntryExitSelfTransitionTest, SelfTransitionFromChildState) {
-	
-	init();
-	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_entries()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_exits()== 0l);
-	
-	EXPECT_TRUE(statechart->isStateActive(EntryExitSelfTransition::main_region_A__region0_C));
-	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(EntryExitSelfTransition::main_region_A__region0_B));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_entries()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_exits()== 1l);
-	
-	statechart->exit();
-	
+	TEST_F(EntryExitSelfTransitionTest, SelfTransitionFromChildState) {
+		
+		init();
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_entries()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_exits()== 0l);
+		
+		EXPECT_TRUE(statechart->isStateActive(EntryExitSelfTransition::main_region_A__region0_C));
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(EntryExitSelfTransition::main_region_A__region0_B));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_entries()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_exits()== 1l);
+		
+		statechart->exit();
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "EntryReactionAction.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static EntryReactionAction* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class EntryReactionActionTest : public ::testing::Test{
 	protected:
+	
+	EntryReactionAction* statechart;
+	
 	virtual void SetUp() {
 		statechart = new EntryReactionAction();
 		statechart->init();
@@ -27,74 +28,79 @@ class EntryReactionActionTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-void init(){
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->raise_b();
-	
-	runner->proceed_cycles(1);
-	
-	statechart->getDefaultSCI()->raise_d();
 	
-	runner->proceed_cycles(1);
-	
-	statechart->getDefaultSCI()->set_enteredR1(false);
-	
-	statechart->getDefaultSCI()->set_enteredR2(false);
-	
-	statechart->getDefaultSCI()->set_enteredBdefault(false);
-	
-	statechart->getDefaultSCI()->set_enteredBother(false);
+	virtual void init() {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->raise_b();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getDefaultSCI()->raise_d();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getDefaultSCI()->set_enteredR1(false);
+		
+		statechart->getDefaultSCI()->set_enteredR2(false);
+		
+		statechart->getDefaultSCI()->set_enteredBdefault(false);
+		
+		statechart->getDefaultSCI()->set_enteredBother(false);
+		
+		
+	}
 	
-}
+};
 
-TEST_F(EntryReactionActionTest, entryTransitionActionOnStatechartEnter) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_enteredR1());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_enteredR2());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_enteredBdefault());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredBother());
-	
+	TEST_F(EntryReactionActionTest, entryTransitionActionOnStatechartEnter) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_enteredR1());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_enteredR2());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_enteredBdefault());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredBother());
+		
+		
 }
-TEST_F(EntryReactionActionTest, entryOnRTS) {
-	
-	init();
-	
-	statechart->getDefaultSCI()->raise_b();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredR1());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredR2());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredBdefault());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_enteredBother());
-	
+	TEST_F(EntryReactionActionTest, entryOnRTS) {
+		
+		init();
+		
+		statechart->getDefaultSCI()->raise_b();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredR1());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredR2());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredBdefault());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_enteredBother());
+		
+		
 }
-TEST_F(EntryReactionActionTest, noEntryTransitionActionOnHistory) {
-	
-	init();
-	
-	statechart->getDefaultSCI()->raise_d();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredR1());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredR2());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredBdefault());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredBother());
-	
+	TEST_F(EntryReactionActionTest, noEntryTransitionActionOnHistory) {
+		
+		init();
+		
+		statechart->getDefaultSCI()->raise_d();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredR1());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredR2());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredBdefault());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_enteredBother());
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "EventDrivenInternalEvent.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static EventDrivenInternalEvent* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class EventDrivenInternalEventTest : public ::testing::Test{
 	protected:
+	
+	EventDrivenInternalEvent* statechart;
+	
 	virtual void SetUp() {
 		statechart = new EventDrivenInternalEvent();
 		statechart->init();
@@ -27,31 +28,33 @@ class EventDrivenInternalEventTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(EventDrivenInternalEventTest, checkInternlEventQueueing) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_r1_A));
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_r2_C));
 	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_check_VALID));
-	
-	statechart->getDefaultSCI()->raise_start();
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_r1_B));
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_r2_D));
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_check_VALID));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_i1_sequence()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_i2_sequence()== 3l);
-	
-	statechart->exit();
 	
+};
+
+	TEST_F(EventDrivenInternalEventTest, checkInternlEventQueueing) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_r1_A));
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_r2_C));
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_check_VALID));
+		
+		statechart->getDefaultSCI()->raise_start();
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_r1_B));
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_r2_D));
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenInternalEvent::EventDrivenInternalEvent_check_VALID));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_i1_sequence()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_i2_sequence()== 3l);
+		
+		statechart->exit();
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "EventDrivenTriggeredByEvent.h"
 #include "sc_runner_timed.h"
 #include "sc_types.h"
+			
 
 
-
-static EventDrivenTriggeredByEvent* statechart;
-
 //! The timers are managed by a timer service. */
 static TimedSctUnitRunner * runner;
 
 class EventDrivenTriggeredByEventTest : public ::testing::Test{
 	protected:
+	
+	EventDrivenTriggeredByEvent* statechart;
+	
 	virtual void SetUp() {
 		statechart = new EventDrivenTriggeredByEvent();
 		statechart->init();
@@ -28,40 +29,43 @@ class EventDrivenTriggeredByEventTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(EventDrivenTriggeredByEventTest, internalEventTriggersRunCycle) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByEvent::EventDrivenTriggeredByEvent_main_region_A));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByEvent::EventDrivenTriggeredByEvent_main_region_B));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
 	
-	statechart->getDefaultSCI()->raise_e();
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByEvent::EventDrivenTriggeredByEvent_main_region_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
-	
-	statechart->exit();
 	
+};
+
+	TEST_F(EventDrivenTriggeredByEventTest, internalEventTriggersRunCycle) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByEvent::EventDrivenTriggeredByEvent_main_region_A));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByEvent::EventDrivenTriggeredByEvent_main_region_B));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByEvent::EventDrivenTriggeredByEvent_main_region_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
+		
+		statechart->exit();
+		
+		
 }
-TEST_F(EventDrivenTriggeredByEventTest, proceedTimeDoesNotTriggerRunCycle) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByEvent::EventDrivenTriggeredByEvent_main_region_A));
-	
-	runner->proceed_time(120000);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
-	
-	statechart->exit();
-	
+	TEST_F(EventDrivenTriggeredByEventTest, proceedTimeDoesNotTriggerRunCycle) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByEvent::EventDrivenTriggeredByEvent_main_region_A));
+		
+		runner->proceed_time(120000);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
+		
+		statechart->exit();
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "EventDrivenTriggeredByTimeEvent.h"
 #include "sc_runner_timed.h"
 #include "sc_types.h"
+			
 
 
-
-static EventDrivenTriggeredByTimeEvent* statechart;
-
 //! The timers are managed by a timer service. */
 static TimedSctUnitRunner * runner;
 
 class EventDrivenTriggeredByTimeEventTest : public ::testing::Test{
 	protected:
+	
+	EventDrivenTriggeredByTimeEvent* statechart;
+	
 	virtual void SetUp() {
 		statechart = new EventDrivenTriggeredByTimeEvent();
 		statechart->init();
@@ -28,55 +29,57 @@ class EventDrivenTriggeredByTimeEventTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(EventDrivenTriggeredByTimeEventTest, timeEventTriggersRunCycle) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
-	
-	runner->proceed_time(999);
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
-	
-	runner->proceed_time(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_B));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_transition_count()== 1l);
-	
-	runner->proceed_time(1000);
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_transition_count()== 2l);
-	
-	runner->proceed_time(999000);
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_B));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_transition_count()== 1001l);
-	
-	runner->proceed_time(999000);
-	
-	EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_transition_count()== 2000l);
-	
-	statechart->exit();
 	
+};
+
+	TEST_F(EventDrivenTriggeredByTimeEventTest, timeEventTriggersRunCycle) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
+		
+		runner->proceed_time(999);
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
+		
+		runner->proceed_time(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_B));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_transition_count()== 1l);
+		
+		runner->proceed_time(1000);
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_transition_count()== 2l);
+		
+		runner->proceed_time(999000);
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_B));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_transition_count()== 1001l);
+		
+		runner->proceed_time(999000);
+		
+		EXPECT_TRUE(statechart->isStateActive(EventDrivenTriggeredByTimeEvent::EventDrivenTriggeredByTimeEvent_r_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_transition_count()== 2000l);
+		
+		statechart->exit();
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ExitOnSelfTransition.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ExitOnSelfTransition* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ExitOnSelfTransitionTest : public ::testing::Test{
 	protected:
+	
+	ExitOnSelfTransition* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ExitOnSelfTransition();
 		statechart->init();
@@ -27,33 +28,35 @@ class ExitOnSelfTransitionTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ExitOnSelfTransitionTest, ExitOnSelfTransitionTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ExitOnSelfTransition::main_region_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_entryCount()== 1l);
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_exitCount()== 0l);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_entryCount()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_exitCount()== 1l);
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_entryCount()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_exitCount()== 2l);
 	
+};
+
+	TEST_F(ExitOnSelfTransitionTest, ExitOnSelfTransitionTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ExitOnSelfTransition::main_region_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_entryCount()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_exitCount()== 0l);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_entryCount()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_exitCount()== 1l);
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_entryCount()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_exitCount()== 2l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ExitState.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ExitState* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ExitStateTest : public ::testing::Test{
 	protected:
+	
+	ExitState* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ExitState();
 		statechart->init();
@@ -27,56 +28,61 @@ class ExitStateTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ExitStateTest, defaultExit) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ExitState::r_E));
 	
+};
+
+	TEST_F(ExitStateTest, defaultExit) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ExitState::r_E));
+		
+		
 }
-TEST_F(ExitStateTest, namedExitThroughNamedTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ExitState::r_F));
-	
+	TEST_F(ExitStateTest, namedExitThroughNamedTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ExitState::r_F));
+		
+		
 }
-TEST_F(ExitStateTest, namedExitThroughDefaultTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
-	
-	statechart->getDefaultSCI()->raise_g();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ExitState::r_E));
-	
+	TEST_F(ExitStateTest, namedExitThroughDefaultTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
+		
+		statechart->getDefaultSCI()->raise_g();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ExitState::r_E));
+		
+		
 }
-TEST_F(ExitStateTest, remainInA) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
-	
+	TEST_F(ExitStateTest, remainInA) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ExitState::r_A));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "FeatureCalls.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static FeatureCalls* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class FeatureCallsTest : public ::testing::Test{
 	protected:
+	
+	FeatureCalls* statechart;
+	
 	virtual void SetUp() {
 		statechart = new FeatureCalls();
 		statechart->init();
@@ -27,17 +28,19 @@ class FeatureCallsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(FeatureCallsTest, FeatureCalls) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(FeatureCalls::main_region_A));
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(FeatureCalls::main_region_A));
 	
+};
+
+	TEST_F(FeatureCallsTest, FeatureCalls) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(FeatureCalls::main_region_A));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(FeatureCalls::main_region_A));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "FinalState.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static FinalState* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class FinalStateTest : public ::testing::Test{
 	protected:
+	
+	FinalState* statechart;
+	
 	virtual void SetUp() {
 		statechart = new FinalState();
 		statechart->init();
@@ -27,15 +28,17 @@ class FinalStateTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(FinalStateTest, StatechartNameTest) {
-	
-	statechart->enter();
-	
-	runner->proceed_cycles(1);
 	
-	EXPECT_TRUE(statechart->isFinal());
 	
+};
+
+	TEST_F(FinalStateTest, StatechartNameTest) {
+		
+		statechart->enter();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isFinal());
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "FloatModulo.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static FloatModulo* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class FloatModuloTest : public ::testing::Test{
 	protected:
+	
+	FloatModulo* statechart;
+	
 	virtual void SetUp() {
 		statechart = new FloatModulo();
 		statechart->init();
@@ -27,15 +28,17 @@ class FloatModuloTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(FloatModuloTest, test) {
-	
-	statechart->enter();
-	
-	runner->proceed_cycles(1);
 	
-	EXPECT_TRUE(statechart->isFinal());
 	
+};
+
+	TEST_F(FloatModuloTest, test) {
+		
+		statechart->enter();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isFinal());
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "Guard.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static Guard* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class GuardTest : public ::testing::Test{
 	protected:
+	
+	Guard* statechart;
+	
 	virtual void SetUp() {
 		statechart = new Guard();
 		statechart->init();
@@ -27,43 +28,45 @@ class GuardTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(GuardTest, guardTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(Guard::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Guard::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_event2();
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Guard::main_region_B));
-	
-	statechart->getDefaultSCI()->raise_return();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Guard::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Guard::main_region_B));
-	
-	statechart->getDefaultSCI()->raise_return();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Guard::main_region_A));
 	
+};
+
+	TEST_F(GuardTest, guardTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(Guard::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Guard::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_event2();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Guard::main_region_B));
+		
+		statechart->getDefaultSCI()->raise_return();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Guard::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Guard::main_region_B));
+		
+		statechart->getDefaultSCI()->raise_return();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Guard::main_region_A));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "GuardedEntry.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static GuardedEntry* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class GuardedEntryTest : public ::testing::Test{
 	protected:
+	
+	GuardedEntry* statechart;
+	
 	virtual void SetUp() {
 		statechart = new GuardedEntry();
 		statechart->init();
@@ -27,65 +28,71 @@ class GuardedEntryTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-void initEntryInTransition(bool guardVar, bool doneVar){
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_e();
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_B));
-	
-	statechart->getDefaultSCI()->set_guard(guardVar);
-	
-	statechart->getDefaultSCI()->set_done(doneVar);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_A));
+	virtual void initEntryInTransition(bool guardVar, bool doneVar) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_B));
+		
+		statechart->getDefaultSCI()->set_guard(guardVar);
+		
+		statechart->getDefaultSCI()->set_done(doneVar);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_A));
+		
+		
+	}
 	
-}
+};
 
-TEST_F(GuardedEntryTest, EntryNotTakenOnStatechartEnter) {
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_guard()== false);
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_done()== false);
-	
+	TEST_F(GuardedEntryTest, EntryNotTakenOnStatechartEnter) {
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_guard()== false);
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_done()== false);
+		
+		
 }
-TEST_F(GuardedEntryTest, EntryTakenOnStatechartEnter) {
-	
-	statechart->getDefaultSCI()->set_guard(true);
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_done()== true);
-	
+	TEST_F(GuardedEntryTest, EntryTakenOnStatechartEnter) {
+		
+		statechart->getDefaultSCI()->set_guard(true);
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(GuardedEntry::main_region_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_done()== true);
+		
+		
 }
-TEST_F(GuardedEntryTest, EntryTakenInTransition) {
-	
-	initEntryInTransition(true,false);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_done());
-	
+	TEST_F(GuardedEntryTest, EntryTakenInTransition) {
+		
+		initEntryInTransition(true,false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_done());
+		
+		
 }
-TEST_F(GuardedEntryTest, EntryNotTakenInTransition) {
-	
-	initEntryInTransition(false,false);
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_done());
-	
+	TEST_F(GuardedEntryTest, EntryNotTakenInTransition) {
+		
+		initEntryInTransition(false,false);
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_done());
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "GuardedExit.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static GuardedExit* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class GuardedExitTest : public ::testing::Test{
 	protected:
+	
+	GuardedExit* statechart;
+	
 	virtual void SetUp() {
 		statechart = new GuardedExit();
 		statechart->init();
@@ -27,39 +28,43 @@ class GuardedExitTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-void checkDone(bool shouldBeDone){
 	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(GuardedExit::main_region_B));
-	
-	EXPECT_TRUE(shouldBeDone ? statechart->getDefaultSCI()->get_done()  : !statechart->getDefaultSCI()->get_done());
+	virtual void checkDone(bool shouldBeDone) {
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(GuardedExit::main_region_B));
+		
+		EXPECT_TRUE(shouldBeDone ? statechart->getDefaultSCI()->get_done()  : !statechart->getDefaultSCI()->get_done());
+		
+		
+	}
 	
-}
+};
 
-TEST_F(GuardedExitTest, ExitTaken) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(GuardedExit::main_region_A));
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_guard());
-	
-	checkDone(false);
-	
+	TEST_F(GuardedExitTest, ExitTaken) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(GuardedExit::main_region_A));
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_guard());
+		
+		checkDone(false);
+		
+		
 }
-TEST_F(GuardedExitTest, ExitNotTaken) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(GuardedExit::main_region_A));
-	
-	statechart->getDefaultSCI()->set_guard(true);
-	
-	checkDone(true);
-	
+	TEST_F(GuardedExitTest, ExitNotTaken) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(GuardedExit::main_region_A));
+		
+		statechart->getDefaultSCI()->set_guard(true);
+		
+		checkDone(true);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "HistoryWithExitPoint.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static HistoryWithExitPoint* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class HistoryWithExitPointTest : public ::testing::Test{
 	protected:
+	
+	HistoryWithExitPoint* statechart;
+	
 	virtual void SetUp() {
 		statechart = new HistoryWithExitPoint();
 		statechart->init();
@@ -27,43 +28,45 @@ class HistoryWithExitPointTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(HistoryWithExitPointTest, historyEntryAfterExit) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_A_r_X1));
-	
-	statechart->getDefaultSCI()->raise_push();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_B));
-	
-	statechart->getDefaultSCI()->raise_back();
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_A_r_X1));
-	
-	statechart->getDefaultSCI()->raise_next();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_A_r_X2));
-	
-	statechart->getDefaultSCI()->raise_push();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_B));
-	
-	statechart->getDefaultSCI()->raise_back();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_A_r_X2));
 	
+};
+
+	TEST_F(HistoryWithExitPointTest, historyEntryAfterExit) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_A_r_X1));
+		
+		statechart->getDefaultSCI()->raise_push();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_B));
+		
+		statechart->getDefaultSCI()->raise_back();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_A_r_X1));
+		
+		statechart->getDefaultSCI()->raise_next();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_A_r_X2));
+		
+		statechart->getDefaultSCI()->raise_push();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_B));
+		
+		statechart->getDefaultSCI()->raise_back();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithExitPoint::mr_A_r_X2));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "HistoryWithoutInitialStep.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static HistoryWithoutInitialStep* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class HistoryWithoutInitialStepTest : public ::testing::Test{
 	protected:
+	
+	HistoryWithoutInitialStep* statechart;
+	
 	virtual void SetUp() {
 		statechart = new HistoryWithoutInitialStep();
 		statechart->init();
@@ -27,72 +28,77 @@ class HistoryWithoutInitialStepTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-void init(){
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_A));
 	
-	statechart->getDefaultSCI()->raise_toB();
-	
-	runner->proceed_cycles(1);
+	virtual void init() {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_toB();
+		
+		runner->proceed_cycles(1);
+		
+		
+	}
 	
-}
+};
 
-TEST_F(HistoryWithoutInitialStepTest, enterThroughInitialEntry) {
-	
-	init();
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_C));
-	
-	statechart->getDefaultSCI()->raise_next();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_D));
-	
+	TEST_F(HistoryWithoutInitialStepTest, enterThroughInitialEntry) {
+		
+		init();
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_C));
+		
+		statechart->getDefaultSCI()->raise_next();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_D));
+		
+		
 }
-TEST_F(HistoryWithoutInitialStepTest, enterCThroughHistory) {
-	
-	init();
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_C));
-	
-	statechart->getDefaultSCI()->raise_toA();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_toHistory();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_C));
-	
+	TEST_F(HistoryWithoutInitialStepTest, enterCThroughHistory) {
+		
+		init();
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_C));
+		
+		statechart->getDefaultSCI()->raise_toA();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_toHistory();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_C));
+		
+		
 }
-TEST_F(HistoryWithoutInitialStepTest, enterDThroughHistory) {
-	
-	init();
-	
-	statechart->getDefaultSCI()->raise_next();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_D));
-	
-	statechart->getDefaultSCI()->raise_toA();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_toHistory();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_D));
-	
+	TEST_F(HistoryWithoutInitialStepTest, enterDThroughHistory) {
+		
+		init();
+		
+		statechart->getDefaultSCI()->raise_next();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_D));
+		
+		statechart->getDefaultSCI()->raise_toA();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_toHistory();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(HistoryWithoutInitialStep::main_region_B_r1_D));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "InEventLifeCycle.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static InEventLifeCycle* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class InEventLifeCycleTest : public ::testing::Test{
 	protected:
+	
+	InEventLifeCycle* statechart;
+	
 	virtual void SetUp() {
 		statechart = new InEventLifeCycle();
 		statechart->init();
@@ -27,19 +28,21 @@ class InEventLifeCycleTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(InEventLifeCycleTest, eventLifeCycle) {
 	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_i()== 0l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_i()== 1l);
 	
+};
+
+	TEST_F(InEventLifeCycleTest, eventLifeCycle) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_i()== 0l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_i()== 1l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "IntegerExpressions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static IntegerExpressions* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class IntegerExpressionsTest : public ::testing::Test{
 	protected:
+	
+	IntegerExpressions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new IntegerExpressions();
 		statechart->init();
@@ -27,55 +28,57 @@ class IntegerExpressionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(IntegerExpressionsTest, integerExpressions) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(IntegerExpressions::main_region_StateA));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt1()== 10l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt2()== 5l);
-	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_less()== false);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_greater()== true);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_equalOrLess()== false);
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_equalOrGreater()== true);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_equal()== false);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_notEqual()== true);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_plus()== 15l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_minus()== 5l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_multiply()== 50l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_division()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_modulo()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_negat()== - 10l );
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_multiAssign()== 20l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_divAssign()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_plusAssign()== 12l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_minusAssign()== - 8l );
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_moduloAssign()== 0l);
 	
+};
+
+	TEST_F(IntegerExpressionsTest, integerExpressions) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(IntegerExpressions::main_region_StateA));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt1()== 10l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt2()== 5l);
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_less()== false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_greater()== true);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_equalOrLess()== false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_equalOrGreater()== true);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_equal()== false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_notEqual()== true);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_plus()== 15l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_minus()== 5l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_multiply()== 50l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_division()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_modulo()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_negat()== - 10l );
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_multiAssign()== 20l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_divAssign()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_plusAssign()== 12l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_minusAssign()== - 8l );
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_moduloAssign()== 0l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "InternalEventLifeCycle.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static InternalEventLifeCycle* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class InternalEventLifeCycleTest : public ::testing::Test{
 	protected:
+	
+	InternalEventLifeCycle* statechart;
+	
 	virtual void SetUp() {
 		statechart = new InternalEventLifeCycle();
 		statechart->init();
@@ -27,43 +28,45 @@ class InternalEventLifeCycleTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(InternalEventLifeCycleTest, InternalEventLifeCycleTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
-	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_C));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
 	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_D));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
-	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_D));
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
-	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_C));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
-	
-	EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_C));
 	
+};
+
+	TEST_F(InternalEventLifeCycleTest, InternalEventLifeCycleTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_C));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_D));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_D));
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_C));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r1_A));
+		
+		EXPECT_TRUE(statechart->isStateActive(InternalEventLifeCycle::r2_C));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "LocalReactions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static LocalReactions* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class LocalReactionsTest : public ::testing::Test{
 	protected:
+	
+	LocalReactions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new LocalReactions();
 		statechart->init();
@@ -27,17 +28,19 @@ class LocalReactionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(LocalReactionsTest, LocalReactionsTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(LocalReactions::main_region_A));
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 1l);
 	
+};
+
+	TEST_F(LocalReactionsTest, LocalReactionsTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(LocalReactions::main_region_A));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 1l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "LogicalAnd.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static LogicalAnd* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class LogicalAndTests : public ::testing::Test{
 	protected:
+	
+	LogicalAnd* statechart;
+	
 	virtual void SetUp() {
 		statechart = new LogicalAnd();
 		statechart->init();
@@ -27,15 +28,17 @@ class LogicalAndTests : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(LogicalAndTests, operandEvaluationOrder) {
-	
-	statechart->enter();
-	
-	runner->proceed_cycles(1);
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 4l && statechart->getDefaultSCI()->get_b()) << "logical and expression was executed in wrong order..." ;
 	
+};
+
+	TEST_F(LogicalAndTests, operandEvaluationOrder) {
+		
+		statechart->enter();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 4l && statechart->getDefaultSCI()->get_b()) << "logical and expression was executed in wrong order..." ;
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "LogicalOr.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static LogicalOr* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class LogicalOrTests : public ::testing::Test{
 	protected:
+	
+	LogicalOr* statechart;
+	
 	virtual void SetUp() {
 		statechart = new LogicalOr();
 		statechart->init();
@@ -27,15 +28,17 @@ class LogicalOrTests : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(LogicalOrTests, operandEvaluationOrder) {
-	
-	statechart->enter();
-	
-	runner->proceed_cycles(1);
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 4l && statechart->getDefaultSCI()->get_b()) << "logical or expression was executed in wrong order..." ;
 	
+};
+
+	TEST_F(LogicalOrTests, operandEvaluationOrder) {
+		
+		statechart->enter();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 4l && statechart->getDefaultSCI()->get_b()) << "logical or expression was executed in wrong order..." ;
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "NamedInterfaceAccess.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static NamedInterfaceAccess* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class NamedInterfaceAccessTest : public ::testing::Test{
 	protected:
+	
+	NamedInterfaceAccess* statechart;
+	
 	virtual void SetUp() {
 		statechart = new NamedInterfaceAccess();
 		statechart->init();
@@ -27,27 +28,29 @@ class NamedInterfaceAccessTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(NamedInterfaceAccessTest, SafeOpenSuccess) {
-	
-	statechart->enter();
-	
-	runner->proceed_cycles(1);
 	
-	statechart->getSCI_User()->raise_numberPressed(3l);
-	
-	runner->proceed_cycles(1);
-	
-	statechart->getSCI_User()->raise_numberPressed(7l);
-	
-	runner->proceed_cycles(1);
-	
-	statechart->getSCI_User()->raise_numberPressed(5l);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getSCI_Safe()->isRaised_open());
 	
+};
+
+	TEST_F(NamedInterfaceAccessTest, SafeOpenSuccess) {
+		
+		statechart->enter();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getSCI_User()->raise_numberPressed(3l);
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getSCI_User()->raise_numberPressed(7l);
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getSCI_User()->raise_numberPressed(5l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getSCI_Safe()->isRaised_open());
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "NullCheck.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static NullCheck* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class NullCheckTest : public ::testing::Test{
 	protected:
+	
+	NullCheck* statechart;
+	
 	virtual void SetUp() {
 		statechart = new NullCheck();
 		statechart->init();
@@ -27,17 +28,19 @@ class NullCheckTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(NullCheckTest, SimpleNullCheckTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(NullCheck::main_region_A));
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(NullCheck::main_region_B));
 	
+};
+
+	TEST_F(NullCheckTest, SimpleNullCheckTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(NullCheck::main_region_A));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(NullCheck::main_region_B));
+		
+		
 }

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

@@ -9,8 +9,7 @@
 using ::testing::AtLeast;
 using ::testing::Return;
 using ::testing::_;
-
-
+			
 class InternalOperation1Mock{
 	public:
 	int callCount;
@@ -1204,13 +1203,15 @@ class MockDefault : public Operations::DefaultSCI_OCB {
 	}
 };
 
-static Operations* statechart;
 
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class OperationsTest : public ::testing::Test{
 	protected:
+	
+	Operations* statechart;
+	
 	virtual void SetUp() {
 		statechart = new Operations();
 		statechart->init();
@@ -1224,270 +1225,271 @@ class OperationsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(OperationsTest, operationsCalled) {
-	alwaysTrueMock = new AlwaysTrueMock();
-	alwaysTrueMock->initializeBehavior();
-	internalOperation1Mock = new InternalOperation1Mock();
-	internalOperation2Mock = new InternalOperation2Mock();
-	internalOperation3Mock = new InternalOperation3Mock();
-	internalOperation3aMock = new InternalOperation3aMock();
-	internalOperation4Mock = new InternalOperation4Mock();
-	internalOperation4aMock = new InternalOperation4aMock();
-	internalOperation5Mock = new InternalOperation5Mock();
-	internalOperation5aMock = new InternalOperation5aMock();
-	interface1InterfaceOperation1Mock = new Interface1InterfaceOperation1Mock();
-	interface1InterfaceOperation2Mock = new Interface1InterfaceOperation2Mock();
-	interface1InterfaceOperation3Mock = new Interface1InterfaceOperation3Mock();
-	interface1InterfaceOperation3aMock = new Interface1InterfaceOperation3aMock();
-	interface1InterfaceOperation4Mock = new Interface1InterfaceOperation4Mock();
-	interface1InterfaceOperation4aMock = new Interface1InterfaceOperation4aMock();
-	interface1InterfaceOperation5Mock = new Interface1InterfaceOperation5Mock();
-	interface1InterfaceOperation5aMock = new Interface1InterfaceOperation5aMock();
-	unnamedInterfaceOperation1Mock = new UnnamedInterfaceOperation1Mock();
-	unnamedInterfaceOperation2Mock = new UnnamedInterfaceOperation2Mock();
-	unnamedOperation3Mock = new UnnamedOperation3Mock();
-	unnamedOperation3aMock = new UnnamedOperation3aMock();
-	unnamedOperation4Mock = new UnnamedOperation4Mock();
-	unnamedOperation4aMock = new UnnamedOperation4aMock();
-	unnamedOperation5Mock = new UnnamedOperation5Mock();
-	unnamedOperation5aMock = new UnnamedOperation5aMock();
-	MockDefault defaultMock;
-	
-	MockInternal internalMock;
-	
-	MockInterface1 interface1Mock;
-	
-	statechart->setDefaultSCI_OCB(&defaultMock);
-	statechart->setInternalSCI_OCB(&internalMock);
-	statechart->setSCI_Interface1_OCB(&interface1Mock);
-	
-	alwaysTrueMock->setDefaultBehavior(&AlwaysTrueMock::alwaysTrue1);
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(Operations::main_region_A));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Operations::main_region_B));
-	
-	EXPECT_TRUE(internalOperation1Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(internalOperation2Mock->calledAtLeastOnce(4l));
-	
-	EXPECT_TRUE(internalOperation3Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(internalOperation3aMock->calledAtLeastOnce(1.0));
-	
-	EXPECT_TRUE(internalOperation4Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(internalOperation4aMock->calledAtLeastOnce(5l));
-	
-	EXPECT_TRUE(internalOperation5Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(internalOperation5aMock->calledAtLeastOnce());
-	
-	statechart->getDefaultSCI()->raise_ev();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Operations::main_region_C));
-	
-	EXPECT_TRUE(interface1InterfaceOperation1Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(interface1InterfaceOperation2Mock->calledAtLeastOnce(4l));
-	
-	EXPECT_TRUE(interface1InterfaceOperation3Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(interface1InterfaceOperation3aMock->calledAtLeastOnce(1.0));
-	
-	EXPECT_TRUE(interface1InterfaceOperation4Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(interface1InterfaceOperation4aMock->calledAtLeastOnce(5l));
-	
-	EXPECT_TRUE(interface1InterfaceOperation5Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(interface1InterfaceOperation5aMock->calledAtLeastOnce());
-	
-	statechart->getDefaultSCI()->raise_ev();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Operations::main_region_D));
-	
-	EXPECT_TRUE(unnamedInterfaceOperation1Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(unnamedInterfaceOperation2Mock->calledAtLeastOnce(4l));
-	
-	EXPECT_TRUE(unnamedOperation3Mock->calledAtLeastOnce());
 	
-	EXPECT_TRUE(unnamedOperation3aMock->calledAtLeastOnce(1.0));
 	
-	EXPECT_TRUE(unnamedOperation4Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(unnamedOperation4aMock->calledAtLeastOnce(5l));
-	
-	EXPECT_TRUE(unnamedOperation5Mock->calledAtLeastOnce());
-	
-	EXPECT_TRUE(unnamedOperation5aMock->calledAtLeastOnce());
-	
-	
-	alwaysTrueMock->reset();
-	internalOperation1Mock->reset();
-	internalOperation2Mock->reset();
-	internalOperation3Mock->reset();
-	internalOperation3aMock->reset();
-	internalOperation4Mock->reset();
-	internalOperation4aMock->reset();
-	internalOperation5Mock->reset();
-	internalOperation5aMock->reset();
-	interface1InterfaceOperation1Mock->reset();
-	interface1InterfaceOperation2Mock->reset();
-	interface1InterfaceOperation3Mock->reset();
-	interface1InterfaceOperation3aMock->reset();
-	interface1InterfaceOperation4Mock->reset();
-	interface1InterfaceOperation4aMock->reset();
-	interface1InterfaceOperation5Mock->reset();
-	interface1InterfaceOperation5aMock->reset();
-	unnamedInterfaceOperation1Mock->reset();
-	unnamedInterfaceOperation2Mock->reset();
-	unnamedOperation3Mock->reset();
-	unnamedOperation3aMock->reset();
-	unnamedOperation4Mock->reset();
-	unnamedOperation4aMock->reset();
-	unnamedOperation5Mock->reset();
-	unnamedOperation5aMock->reset();
+};
+
+	TEST_F(OperationsTest, operationsCalled) {
+		alwaysTrueMock = new AlwaysTrueMock();
+		alwaysTrueMock->initializeBehavior();
+		internalOperation1Mock = new InternalOperation1Mock();
+		internalOperation2Mock = new InternalOperation2Mock();
+		internalOperation3Mock = new InternalOperation3Mock();
+		internalOperation3aMock = new InternalOperation3aMock();
+		internalOperation4Mock = new InternalOperation4Mock();
+		internalOperation4aMock = new InternalOperation4aMock();
+		internalOperation5Mock = new InternalOperation5Mock();
+		internalOperation5aMock = new InternalOperation5aMock();
+		interface1InterfaceOperation1Mock = new Interface1InterfaceOperation1Mock();
+		interface1InterfaceOperation2Mock = new Interface1InterfaceOperation2Mock();
+		interface1InterfaceOperation3Mock = new Interface1InterfaceOperation3Mock();
+		interface1InterfaceOperation3aMock = new Interface1InterfaceOperation3aMock();
+		interface1InterfaceOperation4Mock = new Interface1InterfaceOperation4Mock();
+		interface1InterfaceOperation4aMock = new Interface1InterfaceOperation4aMock();
+		interface1InterfaceOperation5Mock = new Interface1InterfaceOperation5Mock();
+		interface1InterfaceOperation5aMock = new Interface1InterfaceOperation5aMock();
+		unnamedInterfaceOperation1Mock = new UnnamedInterfaceOperation1Mock();
+		unnamedInterfaceOperation2Mock = new UnnamedInterfaceOperation2Mock();
+		unnamedOperation3Mock = new UnnamedOperation3Mock();
+		unnamedOperation3aMock = new UnnamedOperation3aMock();
+		unnamedOperation4Mock = new UnnamedOperation4Mock();
+		unnamedOperation4aMock = new UnnamedOperation4aMock();
+		unnamedOperation5Mock = new UnnamedOperation5Mock();
+		unnamedOperation5aMock = new UnnamedOperation5aMock();
+		MockDefault defaultMock;
+		
+		MockInternal internalMock;
+		
+		MockInterface1 interface1Mock;
+		
+		statechart->setDefaultSCI_OCB(&defaultMock);
+		statechart->setInternalSCI_OCB(&internalMock);
+		statechart->setSCI_Interface1_OCB(&interface1Mock);
+		
+		alwaysTrueMock->setDefaultBehavior(&AlwaysTrueMock::alwaysTrue1);
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(Operations::main_region_A));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Operations::main_region_B));
+		
+		EXPECT_TRUE(internalOperation1Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(internalOperation2Mock->calledAtLeastOnce(4l));
+		
+		EXPECT_TRUE(internalOperation3Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(internalOperation3aMock->calledAtLeastOnce(1.0));
+		
+		EXPECT_TRUE(internalOperation4Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(internalOperation4aMock->calledAtLeastOnce(5l));
+		
+		EXPECT_TRUE(internalOperation5Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(internalOperation5aMock->calledAtLeastOnce());
+		
+		statechart->getDefaultSCI()->raise_ev();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Operations::main_region_C));
+		
+		EXPECT_TRUE(interface1InterfaceOperation1Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(interface1InterfaceOperation2Mock->calledAtLeastOnce(4l));
+		
+		EXPECT_TRUE(interface1InterfaceOperation3Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(interface1InterfaceOperation3aMock->calledAtLeastOnce(1.0));
+		
+		EXPECT_TRUE(interface1InterfaceOperation4Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(interface1InterfaceOperation4aMock->calledAtLeastOnce(5l));
+		
+		EXPECT_TRUE(interface1InterfaceOperation5Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(interface1InterfaceOperation5aMock->calledAtLeastOnce());
+		
+		statechart->getDefaultSCI()->raise_ev();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Operations::main_region_D));
+		
+		EXPECT_TRUE(unnamedInterfaceOperation1Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(unnamedInterfaceOperation2Mock->calledAtLeastOnce(4l));
+		
+		EXPECT_TRUE(unnamedOperation3Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(unnamedOperation3aMock->calledAtLeastOnce(1.0));
+		
+		EXPECT_TRUE(unnamedOperation4Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(unnamedOperation4aMock->calledAtLeastOnce(5l));
+		
+		EXPECT_TRUE(unnamedOperation5Mock->calledAtLeastOnce());
+		
+		EXPECT_TRUE(unnamedOperation5aMock->calledAtLeastOnce());
+		
+		
+		alwaysTrueMock->reset();
+		internalOperation1Mock->reset();
+		internalOperation2Mock->reset();
+		internalOperation3Mock->reset();
+		internalOperation3aMock->reset();
+		internalOperation4Mock->reset();
+		internalOperation4aMock->reset();
+		internalOperation5Mock->reset();
+		internalOperation5aMock->reset();
+		interface1InterfaceOperation1Mock->reset();
+		interface1InterfaceOperation2Mock->reset();
+		interface1InterfaceOperation3Mock->reset();
+		interface1InterfaceOperation3aMock->reset();
+		interface1InterfaceOperation4Mock->reset();
+		interface1InterfaceOperation4aMock->reset();
+		interface1InterfaceOperation5Mock->reset();
+		interface1InterfaceOperation5aMock->reset();
+		unnamedInterfaceOperation1Mock->reset();
+		unnamedInterfaceOperation2Mock->reset();
+		unnamedOperation3Mock->reset();
+		unnamedOperation3aMock->reset();
+		unnamedOperation4Mock->reset();
+		unnamedOperation4aMock->reset();
+		unnamedOperation5Mock->reset();
+		unnamedOperation5aMock->reset();
 }
-TEST_F(OperationsTest, operationsNotCalled) {
-	alwaysTrueMock = new AlwaysTrueMock();
-	alwaysTrueMock->initializeBehavior();
-	internalOperation1Mock = new InternalOperation1Mock();
-	internalOperation2Mock = new InternalOperation2Mock();
-	internalOperation3Mock = new InternalOperation3Mock();
-	internalOperation3aMock = new InternalOperation3aMock();
-	internalOperation4Mock = new InternalOperation4Mock();
-	internalOperation4aMock = new InternalOperation4aMock();
-	internalOperation5Mock = new InternalOperation5Mock();
-	internalOperation5aMock = new InternalOperation5aMock();
-	interface1InterfaceOperation1Mock = new Interface1InterfaceOperation1Mock();
-	interface1InterfaceOperation2Mock = new Interface1InterfaceOperation2Mock();
-	interface1InterfaceOperation3Mock = new Interface1InterfaceOperation3Mock();
-	interface1InterfaceOperation3aMock = new Interface1InterfaceOperation3aMock();
-	interface1InterfaceOperation4Mock = new Interface1InterfaceOperation4Mock();
-	interface1InterfaceOperation4aMock = new Interface1InterfaceOperation4aMock();
-	interface1InterfaceOperation5Mock = new Interface1InterfaceOperation5Mock();
-	interface1InterfaceOperation5aMock = new Interface1InterfaceOperation5aMock();
-	unnamedInterfaceOperation1Mock = new UnnamedInterfaceOperation1Mock();
-	unnamedInterfaceOperation2Mock = new UnnamedInterfaceOperation2Mock();
-	unnamedOperation3Mock = new UnnamedOperation3Mock();
-	unnamedOperation3aMock = new UnnamedOperation3aMock();
-	unnamedOperation4Mock = new UnnamedOperation4Mock();
-	unnamedOperation4aMock = new UnnamedOperation4aMock();
-	unnamedOperation5Mock = new UnnamedOperation5Mock();
-	unnamedOperation5aMock = new UnnamedOperation5aMock();
-	MockDefault defaultMock;
-	
-	MockInternal internalMock;
-	
-	MockInterface1 interface1Mock;
-	
-	statechart->setDefaultSCI_OCB(&defaultMock);
-	statechart->setInternalSCI_OCB(&internalMock);
-	statechart->setSCI_Interface1_OCB(&interface1Mock);
-	
-	alwaysTrueMock->setDefaultBehavior(&AlwaysTrueMock::alwaysTrue1);
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(Operations::main_region_A));
-	
-	EXPECT_FALSE(internalOperation1Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(internalOperation2Mock->calledAtLeastOnce(4l));
-	
-	EXPECT_FALSE(internalOperation3Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(internalOperation3aMock->calledAtLeastOnce(1.0));
-	
-	EXPECT_FALSE(internalOperation4Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(internalOperation4aMock->calledAtLeastOnce(5l));
-	
-	EXPECT_FALSE(internalOperation5Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(internalOperation5aMock->calledAtLeastOnce());
-	
-	statechart->getDefaultSCI()->raise_ev();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Operations::main_region_B));
-	
-	EXPECT_FALSE(interface1InterfaceOperation1Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(interface1InterfaceOperation2Mock->calledAtLeastOnce(4l));
-	
-	EXPECT_FALSE(interface1InterfaceOperation3Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(interface1InterfaceOperation3aMock->calledAtLeastOnce(1.0));
-	
-	EXPECT_FALSE(interface1InterfaceOperation4Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(interface1InterfaceOperation4aMock->calledAtLeastOnce(5l));
-	
-	EXPECT_FALSE(interface1InterfaceOperation5Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(interface1InterfaceOperation5aMock->calledAtLeastOnce());
-	
-	statechart->getDefaultSCI()->raise_ev();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(Operations::main_region_C));
-	
-	EXPECT_FALSE(unnamedInterfaceOperation1Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(unnamedInterfaceOperation2Mock->calledAtLeastOnce(4l));
-	
-	EXPECT_FALSE(unnamedOperation3Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(unnamedOperation3aMock->calledAtLeastOnce(1.0));
-	
-	EXPECT_FALSE(unnamedOperation4Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(unnamedOperation4aMock->calledAtLeastOnce(5l));
-	
-	EXPECT_FALSE(unnamedOperation5Mock->calledAtLeastOnce());
-	
-	EXPECT_FALSE(unnamedOperation5aMock->calledAtLeastOnce());
-	
-	
-	alwaysTrueMock->reset();
-	internalOperation1Mock->reset();
-	internalOperation2Mock->reset();
-	internalOperation3Mock->reset();
-	internalOperation3aMock->reset();
-	internalOperation4Mock->reset();
-	internalOperation4aMock->reset();
-	internalOperation5Mock->reset();
-	internalOperation5aMock->reset();
-	interface1InterfaceOperation1Mock->reset();
-	interface1InterfaceOperation2Mock->reset();
-	interface1InterfaceOperation3Mock->reset();
-	interface1InterfaceOperation3aMock->reset();
-	interface1InterfaceOperation4Mock->reset();
-	interface1InterfaceOperation4aMock->reset();
-	interface1InterfaceOperation5Mock->reset();
-	interface1InterfaceOperation5aMock->reset();
-	unnamedInterfaceOperation1Mock->reset();
-	unnamedInterfaceOperation2Mock->reset();
-	unnamedOperation3Mock->reset();
-	unnamedOperation3aMock->reset();
-	unnamedOperation4Mock->reset();
-	unnamedOperation4aMock->reset();
-	unnamedOperation5Mock->reset();
-	unnamedOperation5aMock->reset();
+	TEST_F(OperationsTest, operationsNotCalled) {
+		alwaysTrueMock = new AlwaysTrueMock();
+		alwaysTrueMock->initializeBehavior();
+		internalOperation1Mock = new InternalOperation1Mock();
+		internalOperation2Mock = new InternalOperation2Mock();
+		internalOperation3Mock = new InternalOperation3Mock();
+		internalOperation3aMock = new InternalOperation3aMock();
+		internalOperation4Mock = new InternalOperation4Mock();
+		internalOperation4aMock = new InternalOperation4aMock();
+		internalOperation5Mock = new InternalOperation5Mock();
+		internalOperation5aMock = new InternalOperation5aMock();
+		interface1InterfaceOperation1Mock = new Interface1InterfaceOperation1Mock();
+		interface1InterfaceOperation2Mock = new Interface1InterfaceOperation2Mock();
+		interface1InterfaceOperation3Mock = new Interface1InterfaceOperation3Mock();
+		interface1InterfaceOperation3aMock = new Interface1InterfaceOperation3aMock();
+		interface1InterfaceOperation4Mock = new Interface1InterfaceOperation4Mock();
+		interface1InterfaceOperation4aMock = new Interface1InterfaceOperation4aMock();
+		interface1InterfaceOperation5Mock = new Interface1InterfaceOperation5Mock();
+		interface1InterfaceOperation5aMock = new Interface1InterfaceOperation5aMock();
+		unnamedInterfaceOperation1Mock = new UnnamedInterfaceOperation1Mock();
+		unnamedInterfaceOperation2Mock = new UnnamedInterfaceOperation2Mock();
+		unnamedOperation3Mock = new UnnamedOperation3Mock();
+		unnamedOperation3aMock = new UnnamedOperation3aMock();
+		unnamedOperation4Mock = new UnnamedOperation4Mock();
+		unnamedOperation4aMock = new UnnamedOperation4aMock();
+		unnamedOperation5Mock = new UnnamedOperation5Mock();
+		unnamedOperation5aMock = new UnnamedOperation5aMock();
+		MockDefault defaultMock;
+		
+		MockInternal internalMock;
+		
+		MockInterface1 interface1Mock;
+		
+		statechart->setDefaultSCI_OCB(&defaultMock);
+		statechart->setInternalSCI_OCB(&internalMock);
+		statechart->setSCI_Interface1_OCB(&interface1Mock);
+		
+		alwaysTrueMock->setDefaultBehavior(&AlwaysTrueMock::alwaysTrue1);
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(Operations::main_region_A));
+		
+		EXPECT_FALSE(internalOperation1Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(internalOperation2Mock->calledAtLeastOnce(4l));
+		
+		EXPECT_FALSE(internalOperation3Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(internalOperation3aMock->calledAtLeastOnce(1.0));
+		
+		EXPECT_FALSE(internalOperation4Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(internalOperation4aMock->calledAtLeastOnce(5l));
+		
+		EXPECT_FALSE(internalOperation5Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(internalOperation5aMock->calledAtLeastOnce());
+		
+		statechart->getDefaultSCI()->raise_ev();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Operations::main_region_B));
+		
+		EXPECT_FALSE(interface1InterfaceOperation1Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(interface1InterfaceOperation2Mock->calledAtLeastOnce(4l));
+		
+		EXPECT_FALSE(interface1InterfaceOperation3Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(interface1InterfaceOperation3aMock->calledAtLeastOnce(1.0));
+		
+		EXPECT_FALSE(interface1InterfaceOperation4Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(interface1InterfaceOperation4aMock->calledAtLeastOnce(5l));
+		
+		EXPECT_FALSE(interface1InterfaceOperation5Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(interface1InterfaceOperation5aMock->calledAtLeastOnce());
+		
+		statechart->getDefaultSCI()->raise_ev();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(Operations::main_region_C));
+		
+		EXPECT_FALSE(unnamedInterfaceOperation1Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(unnamedInterfaceOperation2Mock->calledAtLeastOnce(4l));
+		
+		EXPECT_FALSE(unnamedOperation3Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(unnamedOperation3aMock->calledAtLeastOnce(1.0));
+		
+		EXPECT_FALSE(unnamedOperation4Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(unnamedOperation4aMock->calledAtLeastOnce(5l));
+		
+		EXPECT_FALSE(unnamedOperation5Mock->calledAtLeastOnce());
+		
+		EXPECT_FALSE(unnamedOperation5aMock->calledAtLeastOnce());
+		
+		
+		alwaysTrueMock->reset();
+		internalOperation1Mock->reset();
+		internalOperation2Mock->reset();
+		internalOperation3Mock->reset();
+		internalOperation3aMock->reset();
+		internalOperation4Mock->reset();
+		internalOperation4aMock->reset();
+		internalOperation5Mock->reset();
+		internalOperation5aMock->reset();
+		interface1InterfaceOperation1Mock->reset();
+		interface1InterfaceOperation2Mock->reset();
+		interface1InterfaceOperation3Mock->reset();
+		interface1InterfaceOperation3aMock->reset();
+		interface1InterfaceOperation4Mock->reset();
+		interface1InterfaceOperation4aMock->reset();
+		interface1InterfaceOperation5Mock->reset();
+		interface1InterfaceOperation5aMock->reset();
+		unnamedInterfaceOperation1Mock->reset();
+		unnamedInterfaceOperation2Mock->reset();
+		unnamedOperation3Mock->reset();
+		unnamedOperation3aMock->reset();
+		unnamedOperation4Mock->reset();
+		unnamedOperation4aMock->reset();
+		unnamedOperation5Mock->reset();
+		unnamedOperation5aMock->reset();
 }

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

@@ -4,16 +4,17 @@
 #include "OutEventLifeCycle.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static OutEventLifeCycle* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class OutEventLifeCycleTest : public ::testing::Test{
 	protected:
+	
+	OutEventLifeCycle* statechart;
+	
 	virtual void SetUp() {
 		statechart = new OutEventLifeCycle();
 		statechart->init();
@@ -27,51 +28,57 @@ class OutEventLifeCycleTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-void init(bool sndCycle){
-	
-	statechart->enter();
 	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	if (sndCycle) {
+	virtual void init(bool sndCycle) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->raise_e();
+		
 		runner->proceed_cycles(1);
+		
+		if (sndCycle) {
+			runner->proceed_cycles(1);
+		}
+		
+		
 	}
 	
-}
+};
 
-TEST_F(OutEventLifeCycleTest, availableAfterCycle) {
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->isRaised_f());
-	
+	TEST_F(OutEventLifeCycleTest, availableAfterCycle) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->isRaised_f());
+		
+		
 }
-TEST_F(OutEventLifeCycleTest, availableWithinCycle) {
-	
-	init(false);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_f_available_in_cycle());
-	
+	TEST_F(OutEventLifeCycleTest, availableWithinCycle) {
+		
+		init(false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_f_available_in_cycle());
+		
+		
 }
-TEST_F(OutEventLifeCycleTest, unvailableWithin2ndCycle) {
-	
-	init(true);
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_f_available_in_next_cycle());
-	
+	TEST_F(OutEventLifeCycleTest, unvailableWithin2ndCycle) {
+		
+		init(true);
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_f_available_in_next_cycle());
+		
+		
 }
-TEST_F(OutEventLifeCycleTest, unvailableAfter2ndCycle) {
-	
-	init(true);
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->isRaised_f());
-	
+	TEST_F(OutEventLifeCycleTest, unvailableAfter2ndCycle) {
+		
+		init(true);
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->isRaised_f());
+		
+		
 }

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/OutEventLifeCycleTest/sc_runner.h

@@ -17,7 +17,7 @@ extern "C" {
 class SctUnitRunner {
 	public:
 		SctUnitRunner(StatemachineInterface * statemachine, bool event_driven, sc_integer cycle_period);
-		~SctUnitRunner(){}
+		virtual ~SctUnitRunner(){};
 		void proceed_time(sc_integer time_ms);
 		void proceed_cycles(sc_integer cycles);
 		virtual void cancel();

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

@@ -4,16 +4,17 @@
 #include "ParentFirstExecutionHierarchy.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ParentFirstExecutionHierarchy* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ParentFirstExecutionHierarchyTest : public ::testing::Test{
 	protected:
+	
+	ParentFirstExecutionHierarchy* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ParentFirstExecutionHierarchy();
 		statechart->init();
@@ -27,109 +28,115 @@ class ParentFirstExecutionHierarchyTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-void assertNoLocalReaction(){
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_local());
 	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_local());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_local());
+	virtual void assertNoLocalReaction() {
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_local());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_local());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_local());
+		
+		
+	}
 	
-}
+};
 
-TEST_F(ParentFirstExecutionHierarchyTest, childShouldTakeTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->set_disable_a(true);
-	
-	statechart->getDefaultSCI()->set_disable_aa(true);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_B));
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_reacted());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_reacted());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_local());
-	
+	TEST_F(ParentFirstExecutionHierarchyTest, childShouldTakeTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->set_disable_a(true);
+		
+		statechart->getDefaultSCI()->set_disable_aa(true);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_B));
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_reacted());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_reacted());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_local());
+		
+		
 }
-TEST_F(ParentFirstExecutionHierarchyTest, parentShouldTakeTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->set_disable_a(true);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_B));
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_reacted());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_reacted());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_local());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_local());
-	
+	TEST_F(ParentFirstExecutionHierarchyTest, parentShouldTakeTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->set_disable_a(true);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_B));
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_a_reacted());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_reacted());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_local());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_local());
+		
+		
 }
-TEST_F(ParentFirstExecutionHierarchyTest, grandparentShouldTakeTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_B));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_reacted());
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_reacted());
-	
-	assertNoLocalReaction();
-	
+	TEST_F(ParentFirstExecutionHierarchyTest, grandparentShouldTakeTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_B));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aa_reacted());
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_aaa_reacted());
+		
+		assertNoLocalReaction();
+		
+		
 }
-TEST_F(ParentFirstExecutionHierarchyTest, expectLocalReactrionsExecuteWithNoTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local());
-	
+	TEST_F(ParentFirstExecutionHierarchyTest, expectLocalReactrionsExecuteWithNoTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstExecutionHierarchy::ParentFirstExecutionHierarchy_r_A_r_AA_r_AAA));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local());
+		
+		
 }

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

@@ -4,17 +4,18 @@
 #include "ParentFirstLocalReactions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
-static long counter = 0l;
-
-
-static ParentFirstLocalReactions* statechart;
+long counter = 0l;
 
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ParentFirstLocalReactionsTest : public ::testing::Test{
 	protected:
+	
+	ParentFirstLocalReactions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ParentFirstLocalReactions();
 		statechart->init();
@@ -28,98 +29,103 @@ class ParentFirstLocalReactionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ParentFirstLocalReactionsTest, expectBottomUpLocalReactionOrder) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 3l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 4l);
 	
+};
+
+	TEST_F(ParentFirstLocalReactionsTest, expectBottomUpLocalReactionOrder) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 3l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 4l);
+		
+		
 }
-TEST_F(ParentFirstLocalReactionsTest, expectParentLocalReactionOnChildLocalTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	statechart->getDefaultSCI()->set_disable_a(true);
-	
-	statechart->getDefaultSCI()->set_disable_aa(true);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAB));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 3l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 0l);
-	
+	TEST_F(ParentFirstLocalReactionsTest, expectParentLocalReactionOnChildLocalTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		statechart->getDefaultSCI()->set_disable_a(true);
+		
+		statechart->getDefaultSCI()->set_disable_aa(true);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAB));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 3l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 0l);
+		
+		
 }
-TEST_F(ParentFirstLocalReactionsTest, expectGrandparentLocalReactionOnParentLocalTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->set_disable_a(true);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AB));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 0l);
-	
+	TEST_F(ParentFirstLocalReactionsTest, expectGrandparentLocalReactionOnParentLocalTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->set_disable_a(true);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AB));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 2l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 0l);
+		
+		
 }
-TEST_F(ParentFirstLocalReactionsTest, expectNoLocalReactionOnGrandparentTransition) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
-	
-	statechart->getDefaultSCI()->set_disable_aaa(true);
-	
-	statechart->getDefaultSCI()->set_disable_aa(true);
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_B));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 1l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 0l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 0l);
-	
+	TEST_F(ParentFirstLocalReactionsTest, expectNoLocalReactionOnGrandparentTransition) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_A_r_AA_r_AAA));
+		
+		statechart->getDefaultSCI()->set_disable_aaa(true);
+		
+		statechart->getDefaultSCI()->set_disable_aa(true);
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ParentFirstLocalReactions::ParentFirstLocalReactions_r_B));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_sm_local()== 1l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_a_local()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aa_local()== 0l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_aaa_local()== 0l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "Parenthesis.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static Parenthesis* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ParenthesisTest : public ::testing::Test{
 	protected:
+	
+	Parenthesis* statechart;
+	
 	virtual void SetUp() {
 		statechart = new Parenthesis();
 		statechart->init();
@@ -27,15 +28,17 @@ class ParenthesisTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ParenthesisTest, simple) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(Parenthesis::mainRegion_A));
 	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_erg()== 8l);
 	
+};
+
+	TEST_F(ParenthesisTest, simple) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(Parenthesis::mainRegion_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_erg()== 8l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "PriorityValues.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static PriorityValues* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class PriorityValuesTest : public ::testing::Test{
 	protected:
+	
+	PriorityValues* statechart;
+	
 	virtual void SetUp() {
 		statechart = new PriorityValues();
 		statechart->init();
@@ -27,34 +28,37 @@ class PriorityValuesTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(PriorityValuesTest, transitionPriority) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(PriorityValues::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_event1();
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(PriorityValues::main_region_C));
 	
+};
+
+	TEST_F(PriorityValuesTest, transitionPriority) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(PriorityValues::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(PriorityValues::main_region_C));
+		
+		
 }
-TEST_F(PriorityValuesTest, regionPriority) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(PriorityValues::someRegion_A));
-	
-	statechart->getDefaultSCI()->raise_event2();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(PriorityValues::someRegion_B));
-	
-	EXPECT_TRUE(!statechart->isStateActive(PriorityValues::main_region_E));
-	
+	TEST_F(PriorityValuesTest, regionPriority) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(PriorityValues::someRegion_A));
+		
+		statechart->getDefaultSCI()->raise_event2();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(PriorityValues::someRegion_B));
+		
+		EXPECT_TRUE(!statechart->isStateActive(PriorityValues::main_region_E));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "RaiseEvent.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static RaiseEvent* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class RaiseEventTest : public ::testing::Test{
 	protected:
+	
+	RaiseEvent* statechart;
+	
 	virtual void SetUp() {
 		statechart = new RaiseEvent();
 		statechart->init();
@@ -27,25 +28,27 @@ class RaiseEventTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(RaiseEventTest, raiseEvent) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(RaiseEvent::second_region_SateA));
-	
-	EXPECT_TRUE(statechart->isStateActive(RaiseEvent::main_region_StateA));
-	
-	statechart->getDefaultSCI()->raise_e2();
-	
-	runner->proceed_cycles(1);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(RaiseEvent::second_region_StateB));
-	
-	EXPECT_TRUE(statechart->isStateActive(RaiseEvent::main_region_StateB));
 	
+};
+
+	TEST_F(RaiseEventTest, raiseEvent) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(RaiseEvent::second_region_SateA));
+		
+		EXPECT_TRUE(statechart->isStateActive(RaiseEvent::main_region_StateA));
+		
+		statechart->getDefaultSCI()->raise_e2();
+		
+		runner->proceed_cycles(1);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(RaiseEvent::second_region_StateB));
+		
+		EXPECT_TRUE(statechart->isStateActive(RaiseEvent::main_region_StateB));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ReadOnlyVariable.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ReadOnlyVariable* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ReadOnlyVariableTest : public ::testing::Test{
 	protected:
+	
+	ReadOnlyVariable* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ReadOnlyVariable();
 		statechart->init();
@@ -27,49 +28,51 @@ class ReadOnlyVariableTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ReadOnlyVariableTest, ReadOnlyVariableTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ReadOnlyVariable::main_region_StateA));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt()== 0l);
-	
-	EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "testString") == 0);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool()== true);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myReal()== 1.1);
-	
-	EXPECT_TRUE(statechart->getSCI_A()->get_myInt()== 0l);
 	
-	EXPECT_TRUE(strcmp(statechart->getSCI_A()->get_myString(), "testString") == 0);
-	
-	EXPECT_TRUE(statechart->getSCI_A()->get_myBool()== true);
-	
-	EXPECT_TRUE(statechart->getSCI_A()->get_myReal()== 1.1);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ReadOnlyVariable::main_region_StateB));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt()== 100l);
-	
-	EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "fail") == 0);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool()== false);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myReal()== 6.6);
-	
-	EXPECT_TRUE(statechart->getSCI_A()->get_myInt()== 200l);
-	
-	EXPECT_TRUE(strcmp(statechart->getSCI_A()->get_myString(), "A_fail") == 0);
-	
-	EXPECT_TRUE(statechart->getSCI_A()->get_myBool()== false);
-	
-	EXPECT_TRUE(statechart->getSCI_A()->get_myReal()== 7.7);
 	
+};
+
+	TEST_F(ReadOnlyVariableTest, ReadOnlyVariableTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ReadOnlyVariable::main_region_StateA));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt()== 0l);
+		
+		EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "testString") == 0);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool()== true);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myReal()== 1.1);
+		
+		EXPECT_TRUE(statechart->getSCI_A()->get_myInt()== 0l);
+		
+		EXPECT_TRUE(strcmp(statechart->getSCI_A()->get_myString(), "testString") == 0);
+		
+		EXPECT_TRUE(statechart->getSCI_A()->get_myBool()== true);
+		
+		EXPECT_TRUE(statechart->getSCI_A()->get_myReal()== 1.1);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ReadOnlyVariable::main_region_StateB));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt()== 100l);
+		
+		EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "fail") == 0);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool()== false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myReal()== 6.6);
+		
+		EXPECT_TRUE(statechart->getSCI_A()->get_myInt()== 200l);
+		
+		EXPECT_TRUE(strcmp(statechart->getSCI_A()->get_myString(), "A_fail") == 0);
+		
+		EXPECT_TRUE(statechart->getSCI_A()->get_myBool()== false);
+		
+		EXPECT_TRUE(statechart->getSCI_A()->get_myReal()== 7.7);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "SameNameDifferentRegion.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static SameNameDifferentRegion* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class SameNameDifferentRegionTest : public ::testing::Test{
 	protected:
+	
+	SameNameDifferentRegion* statechart;
+	
 	virtual void SetUp() {
 		statechart = new SameNameDifferentRegion();
 		statechart->init();
@@ -27,29 +28,31 @@ class SameNameDifferentRegionTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(SameNameDifferentRegionTest, sameNameDifferenRegionTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateA));
 	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateB));
-	
-	EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateB_r1_StateA));
-	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateB));
-	
-	EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateB_r1_StateB));
 	
+};
+
+	TEST_F(SameNameDifferentRegionTest, sameNameDifferenRegionTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateA));
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateB));
+		
+		EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateB_r1_StateA));
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateB));
+		
+		EXPECT_TRUE(statechart->isStateActive(SameNameDifferentRegion::main_region_StateB_r1_StateB));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ShallowHistory.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ShallowHistory* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ShallowHistoryTest : public ::testing::Test{
 	protected:
+	
+	ShallowHistory* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ShallowHistory();
 		statechart->init();
@@ -27,71 +28,73 @@ class ShallowHistoryTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ShallowHistoryTest, shallowHistoryTest) {
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	runner->proceed_cycles(1);
-	
-	statechart->getDefaultSCI()->raise_event3();
-	
-	runner->proceed_cycles(1);
-	
-	statechart->getDefaultSCI()->raise_event5();
-	
-	runner->proceed_cycles(1);
-	
-	statechart->getDefaultSCI()->raise_event7();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State1));
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
-	
-	statechart->getDefaultSCI()->raise_event6();
-	
-	runner->proceed_cycles(1);
 	
-	EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State6));
-	
-	statechart->getDefaultSCI()->raise_event5();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State8));
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
-	
-	statechart->getDefaultSCI()->raise_event2();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State1));
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State6));
-	
-	EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State1));
-	
-	statechart->getDefaultSCI()->raise_event5();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State6));
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
 	
+};
+
+	TEST_F(ShallowHistoryTest, shallowHistoryTest) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getDefaultSCI()->raise_event3();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getDefaultSCI()->raise_event5();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getDefaultSCI()->raise_event7();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State1));
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		
+		statechart->getDefaultSCI()->raise_event6();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State6));
+		
+		statechart->getDefaultSCI()->raise_event5();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State8));
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		
+		statechart->getDefaultSCI()->raise_event2();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State1));
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State6));
+		
+		EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State1));
+		
+		statechart->getDefaultSCI()->raise_event5();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State6));
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistory::mainRegion_State2__region0_State4__region0_State7__region0_State9));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ShallowHistoryWithDeepEntry.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ShallowHistoryWithDeepEntry* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ShallowHistoryWithDeepEntryTest : public ::testing::Test{
 	protected:
+	
+	ShallowHistoryWithDeepEntry* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ShallowHistoryWithDeepEntry();
 		statechart->init();
@@ -27,95 +28,99 @@ class ShallowHistoryWithDeepEntryTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ShallowHistoryWithDeepEntryTest, noDeepEntryWithinHistory) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
-	
-	statechart->getDefaultSCI()->raise_toZ();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_A));
-	
-	statechart->getDefaultSCI()->raise_toY();
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
-	
-	statechart->getDefaultSCI()->raise_toZ();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_A));
 	
+};
+
+	TEST_F(ShallowHistoryWithDeepEntryTest, noDeepEntryWithinHistory) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
+		
+		statechart->getDefaultSCI()->raise_toZ();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_A));
+		
+		statechart->getDefaultSCI()->raise_toY();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
+		
+		statechart->getDefaultSCI()->raise_toZ();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_A));
+		
+		
 }
-TEST_F(ShallowHistoryWithDeepEntryTest, deepEntryWithinHistory) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
-	
-	statechart->getDefaultSCI()->raise_toZ();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_A));
-	
-	statechart->getDefaultSCI()->raise_toC();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B__region0_C));
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B));
-	
-	statechart->getDefaultSCI()->raise_toY();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
-	
-	statechart->getDefaultSCI()->raise_toZ();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B__region0_C));
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B));
-	
+	TEST_F(ShallowHistoryWithDeepEntryTest, deepEntryWithinHistory) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
+		
+		statechart->getDefaultSCI()->raise_toZ();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_A));
+		
+		statechart->getDefaultSCI()->raise_toC();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B__region0_C));
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B));
+		
+		statechart->getDefaultSCI()->raise_toY();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
+		
+		statechart->getDefaultSCI()->raise_toZ();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B__region0_C));
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B));
+		
+		
 }
-TEST_F(ShallowHistoryWithDeepEntryTest, directDeepEntryIntoHistory) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
-	
-	statechart->getDefaultSCI()->raise_toC();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B__region0_C));
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B));
-	
-	statechart->getDefaultSCI()->raise_toY();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
-	
-	statechart->getDefaultSCI()->raise_toZ();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B__region0_C));
-	
-	EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B));
-	
+	TEST_F(ShallowHistoryWithDeepEntryTest, directDeepEntryIntoHistory) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
+		
+		statechart->getDefaultSCI()->raise_toC();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B__region0_C));
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B));
+		
+		statechart->getDefaultSCI()->raise_toY();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Y));
+		
+		statechart->getDefaultSCI()->raise_toZ();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B__region0_C));
+		
+		EXPECT_TRUE(statechart->isStateActive(ShallowHistoryWithDeepEntry::main_region_Z__region0_B));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "SimpleEvent.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static SimpleEvent* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class SimpleEventTest : public ::testing::Test{
 	protected:
+	
+	SimpleEvent* statechart;
+	
 	virtual void SetUp() {
 		statechart = new SimpleEvent();
 		statechart->init();
@@ -27,25 +28,27 @@ class SimpleEventTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(SimpleEventTest, simpleEventTest) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(SimpleEvent::main_region_A)) << "Expected A to be active" ;
-	
-	EXPECT_TRUE(5l== 5l);
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SimpleEvent::main_region_B)) << "Expected B to be active" ;
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->isStateActive(SimpleEvent::main_region_B));
 	
+};
+
+	TEST_F(SimpleEventTest, simpleEventTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(SimpleEvent::main_region_A)) << "Expected A to be active" ;
+		
+		EXPECT_TRUE(5l== 5l);
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SimpleEvent::main_region_B)) << "Expected B to be active" ;
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->isStateActive(SimpleEvent::main_region_B));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "SimpleHierachy.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static SimpleHierachy* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class SimpleHierachyTest : public ::testing::Test{
 	protected:
+	
+	SimpleHierachy* statechart;
+	
 	virtual void SetUp() {
 		statechart = new SimpleHierachy();
 		statechart->init();
@@ -27,25 +28,27 @@ class SimpleHierachyTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(SimpleHierachyTest, simpleHierachyTest) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(SimpleHierachy::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SimpleHierachy::main_region_B));
-	
-	EXPECT_TRUE(statechart->isStateActive(SimpleHierachy::main_region_B_subregion1_B1));
 	
+};
+
+	TEST_F(SimpleHierachyTest, simpleHierachyTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(SimpleHierachy::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SimpleHierachy::main_region_B));
+		
+		EXPECT_TRUE(statechart->isStateActive(SimpleHierachy::main_region_B_subregion1_B1));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "StateIsActive.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static StateIsActive* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class StateIsActiveTest : public ::testing::Test{
 	protected:
+	
+	StateIsActive* statechart;
+	
 	virtual void SetUp() {
 		statechart = new StateIsActive();
 		statechart->init();
@@ -27,25 +28,27 @@ class StateIsActiveTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(StateIsActiveTest, stateIsActive) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(StateIsActive::R1_R1A));
-	
-	EXPECT_TRUE(statechart->isStateActive(StateIsActive::R2_R2A));
-	
-	statechart->getDefaultSCI()->raise_event1();
-	
-	runner->proceed_cycles(1);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(StateIsActive::R1_R1B));
-	
-	EXPECT_TRUE(statechart->isStateActive(StateIsActive::R2_R2B));
 	
+};
+
+	TEST_F(StateIsActiveTest, stateIsActive) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(StateIsActive::R1_R1A));
+		
+		EXPECT_TRUE(statechart->isStateActive(StateIsActive::R2_R2A));
+		
+		statechart->getDefaultSCI()->raise_event1();
+		
+		runner->proceed_cycles(1);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(StateIsActive::R1_R1B));
+		
+		EXPECT_TRUE(statechart->isStateActive(StateIsActive::R2_R2B));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "StatechartActive.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static StatechartActive* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class StatechartActiveTest : public ::testing::Test{
 	protected:
+	
+	StatechartActive* statechart;
+	
 	virtual void SetUp() {
 		statechart = new StatechartActive();
 		statechart->init();
@@ -27,38 +28,43 @@ class StatechartActiveTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(StatechartActiveTest, inactiveBeforeEnter) {
 	
-	EXPECT_TRUE(!statechart->isActive());
 	
+};
+
+	TEST_F(StatechartActiveTest, inactiveBeforeEnter) {
+		
+		EXPECT_TRUE(!statechart->isActive());
+		
+		
 }
-TEST_F(StatechartActiveTest, activeAfterEnter) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isActive());
-	
+	TEST_F(StatechartActiveTest, activeAfterEnter) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isActive());
+		
+		
 }
-TEST_F(StatechartActiveTest, inactiveAfterExit) {
-	
-	statechart->enter();
-	
-	statechart->exit();
-	
-	EXPECT_TRUE(!statechart->isActive());
-	
+	TEST_F(StatechartActiveTest, inactiveAfterExit) {
+		
+		statechart->enter();
+		
+		statechart->exit();
+		
+		EXPECT_TRUE(!statechart->isActive());
+		
+		
 }
-TEST_F(StatechartActiveTest, activeAfterReenter) {
-	
-	statechart->enter();
-	
-	statechart->exit();
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isActive());
-	
+	TEST_F(StatechartActiveTest, activeAfterReenter) {
+		
+		statechart->enter();
+		
+		statechart->exit();
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isActive());
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "StatechartLocalReactions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static StatechartLocalReactions* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class StatechartLocalReactionsTest : public ::testing::Test{
 	protected:
+	
+	StatechartLocalReactions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new StatechartLocalReactions();
 		statechart->init();
@@ -27,26 +28,28 @@ class StatechartLocalReactionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(StatechartLocalReactionsTest, statechartLocalReactionsTest) {
 	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(StatechartLocalReactions::main_region_S1));
-	
-	EXPECT_TRUE(statechart->isStateActive(StatechartLocalReactions::region2_a));
-	
-	while (statechart->getDefaultSCI()->get_myInt()< 10l) {
+};
+
+	TEST_F(StatechartLocalReactionsTest, statechartLocalReactionsTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(StatechartLocalReactions::main_region_S1));
+		
 		EXPECT_TRUE(statechart->isStateActive(StatechartLocalReactions::region2_a));
-		if (statechart->getDefaultSCI()->get_myInt()%2l== 0l) {
-			EXPECT_TRUE(statechart->isStateActive(StatechartLocalReactions::main_region_S1));
+		
+		while (statechart->getDefaultSCI()->get_myInt()< 10l) {
+			EXPECT_TRUE(statechart->isStateActive(StatechartLocalReactions::region2_a));
+			if (statechart->getDefaultSCI()->get_myInt()%2l== 0l) {
+				EXPECT_TRUE(statechart->isStateActive(StatechartLocalReactions::main_region_S1));
+			}
+			else {
+				EXPECT_TRUE(statechart->isStateActive(StatechartLocalReactions::main_region_S2));
+			}
+			runner->proceed_cycles(1);
 		}
-		else {
-			EXPECT_TRUE(statechart->isStateActive(StatechartLocalReactions::main_region_S2));
-		}
-		runner->proceed_cycles(1);
-	}
-	
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "StatechartKeywords.h"
 #include "sc_runner_timed.h"
 #include "sc_types.h"
+			
 
 
-
-static StatechartKeywords* statechart;
-
 //! The timers are managed by a timer service. */
 static TimedSctUnitRunner * runner;
 
 class StatemachineKeywords : public ::testing::Test{
 	protected:
+	
+	StatechartKeywords* statechart;
+	
 	virtual void SetUp() {
 		statechart = new StatechartKeywords();
 		statechart->init();
@@ -28,13 +29,15 @@ class StatemachineKeywords : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(StatemachineKeywords, statemachineKeywords) {
-	
-	statechart->enter();
 	
-	EXPECT_TRUE(statechart->isStateActive(StatechartKeywords::main_region_Timer));
 	
+};
+
+	TEST_F(StatemachineKeywords, statemachineKeywords) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(StatechartKeywords::main_region_Timer));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "StaticChoice.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static StaticChoice* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class StaticChoiceTest : public ::testing::Test{
 	protected:
+	
+	StaticChoice* statechart;
+	
 	virtual void SetUp() {
 		statechart = new StaticChoice();
 		statechart->init();
@@ -27,15 +28,17 @@ class StaticChoiceTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(StaticChoiceTest, StaticChoiceTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(StaticChoice::main_region_Start));
 	
-	runner->proceed_cycles(1);
 	
+};
+
+	TEST_F(StaticChoiceTest, StaticChoiceTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(StaticChoice::main_region_Start));
+		
+		runner->proceed_cycles(1);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "StringExpressions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static StringExpressions* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class StringExpressionsTest : public ::testing::Test{
 	protected:
+	
+	StringExpressions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new StringExpressions();
 		statechart->init();
@@ -27,73 +28,75 @@ class StringExpressionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(StringExpressionsTest, StringExpressionsTest) {
-	
-	EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_quotedStringX(), "\"X\"") == 0);
-	
-	EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_quotedStringY(), "\"Y\"") == 0);
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_AssignmentChecked));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_VarToVarCompareSucceeded));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringNotEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarNotEqual());
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
 	
-	EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_VarToConstCompareSucceeded));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringNotEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarNotEqual());
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_ConstToVarCompareSucceeded));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringNotEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarNotEqual());
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_ConstToConstCompareSucceeded));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringNotEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarEqual());
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarNotEqual());
 	
+};
+
+	TEST_F(StringExpressionsTest, StringExpressionsTest) {
+		
+		EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_quotedStringX(), "\"X\"") == 0);
+		
+		EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_quotedStringY(), "\"Y\"") == 0);
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_AssignmentChecked));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_VarToVarCompareSucceeded));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringNotEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarNotEqual());
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_VarToConstCompareSucceeded));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringNotEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarNotEqual());
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_ConstToVarCompareSucceeded));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringNotEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarNotEqual());
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(StringExpressions::main_region_ConstToConstCompareSucceeded));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_guardStringNotEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarEqual());
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_stringVarNotEqual());
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "SyncFork.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static SyncFork* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class SyncForkTest : public ::testing::Test{
 	protected:
+	
+	SyncFork* statechart;
+	
 	virtual void SetUp() {
 		statechart = new SyncFork();
 		statechart->init();
@@ -27,49 +28,51 @@ class SyncForkTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(SyncForkTest, syncForkTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r1_C1));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r2_D1));
 	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r1_C2));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r2_D2));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r1_C1));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r2_D1));
 	
+};
+
+	TEST_F(SyncForkTest, syncForkTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r1_C1));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r2_D1));
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r1_C2));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r2_D2));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r1_C1));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncFork::main_region_B_r2_D1));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "SyncJoin.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static SyncJoin* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class SyncJoinTest : public ::testing::Test{
 	protected:
+	
+	SyncJoin* statechart;
+	
 	virtual void SetUp() {
 		statechart = new SyncJoin();
 		statechart->init();
@@ -27,157 +28,161 @@ class SyncJoinTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(SyncJoinTest, syncJoin_C2_Waits) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
-	
-	statechart->getDefaultSCI()->raise_jc();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
-	
-	statechart->getDefaultSCI()->raise_jd();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
-	
-	statechart->getDefaultSCI()->raise_jc();
-	
-	statechart->getDefaultSCI()->raise_jd();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
-	
-	statechart->getDefaultSCI()->raise_jc();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
-	
-	statechart->getDefaultSCI()->raise_jd();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
-	
-	statechart->getDefaultSCI()->raise_jc();
 	
-	statechart->getDefaultSCI()->raise_jd();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_A));
 	
+};
+
+	TEST_F(SyncJoinTest, syncJoin_C2_Waits) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
+		
+		statechart->getDefaultSCI()->raise_jc();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
+		
+		statechart->getDefaultSCI()->raise_jd();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
+		
+		statechart->getDefaultSCI()->raise_jc();
+		
+		statechart->getDefaultSCI()->raise_jd();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
+		
+		statechart->getDefaultSCI()->raise_jc();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
+		
+		statechart->getDefaultSCI()->raise_jd();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
+		
+		statechart->getDefaultSCI()->raise_jc();
+		
+		statechart->getDefaultSCI()->raise_jd();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_A));
+		
+		
 }
-TEST_F(SyncJoinTest, syncJoin_D2_Waits) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
-	
-	statechart->getDefaultSCI()->raise_jc();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
-	
-	statechart->getDefaultSCI()->raise_jd();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
-	
-	statechart->getDefaultSCI()->raise_jc();
-	
-	statechart->getDefaultSCI()->raise_jd();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
-	
+	TEST_F(SyncJoinTest, syncJoin_D2_Waits) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D1));
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
+		
+		statechart->getDefaultSCI()->raise_jc();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
+		
+		statechart->getDefaultSCI()->raise_jd();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
+		
+		statechart->getDefaultSCI()->raise_jc();
+		
+		statechart->getDefaultSCI()->raise_jd();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C1));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r1_C2));
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_B_r2_D2));
+		
+		
 }
-TEST_F(SyncJoinTest, doubleEntryActionBug) {
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->raise_e();
-	
-	statechart->getDefaultSCI()->raise_f();
-	
-	runner->proceed_cycles(1);
-	
-	statechart->getDefaultSCI()->raise_jc();
-	
-	statechart->getDefaultSCI()->raise_jd();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_A));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 1l);
-	
+	TEST_F(SyncJoinTest, doubleEntryActionBug) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->raise_e();
+		
+		statechart->getDefaultSCI()->raise_f();
+		
+		runner->proceed_cycles(1);
+		
+		statechart->getDefaultSCI()->raise_jc();
+		
+		statechart->getDefaultSCI()->raise_jd();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(SyncJoin::main_region_A));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_x()== 1l);
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "TimedTransitions.h"
 #include "sc_runner_timed.h"
 #include "sc_types.h"
+			
 
 
-
-static TimedTransitions* statechart;
-
 //! The timers are managed by a timer service. */
 static TimedSctUnitRunner * runner;
 
 class TimedTransitionsTest : public ::testing::Test{
 	protected:
+	
+	TimedTransitions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new TimedTransitions();
 		statechart->init();
@@ -28,19 +29,21 @@ class TimedTransitionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(TimedTransitionsTest, Timer01) {
 	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(TimedTransitions::main_region_Start));
-	
-	runner->proceed_time(2030);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TimedTransitions::main_region_End));
 	
+};
+
+	TEST_F(TimedTransitionsTest, Timer01) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(TimedTransitions::main_region_Start));
+		
+		runner->proceed_time(2030);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TimedTransitions::main_region_End));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "TransitionWithoutCondition.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static TransitionWithoutCondition* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class TransitionWithoutConditionTest : public ::testing::Test{
 	protected:
+	
+	TransitionWithoutCondition* statechart;
+	
 	virtual void SetUp() {
 		statechart = new TransitionWithoutCondition();
 		statechart->init();
@@ -27,17 +28,19 @@ class TransitionWithoutConditionTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(TransitionWithoutConditionTest, TransitionWithoutConditionTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(TransitionWithoutCondition::main_region_A));
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TransitionWithoutCondition::main_region_B));
 	
+};
+
+	TEST_F(TransitionWithoutConditionTest, TransitionWithoutConditionTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(TransitionWithoutCondition::main_region_A));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TransitionWithoutCondition::main_region_B));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "TriggerExpressionPrecedence.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static TriggerExpressionPrecedence* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class TriggerExpressionPrecedenceTest : public ::testing::Test{
 	protected:
+	
+	TriggerExpressionPrecedence* statechart;
+	
 	virtual void SetUp() {
 		statechart = new TriggerExpressionPrecedence();
 		statechart->init();
@@ -27,58 +28,63 @@ class TriggerExpressionPrecedenceTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(TriggerExpressionPrecedenceTest, unsatisfiedTriggerAndFGuardFalseOrFalse) {
-	
-	statechart->enter();
 	
-	statechart->getDefaultSCI()->set_c1(false);
-	
-	statechart->getDefaultSCI()->set_c2(false);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_e1_transition());
 	
+};
+
+	TEST_F(TriggerExpressionPrecedenceTest, unsatisfiedTriggerAndFGuardFalseOrFalse) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->set_c1(false);
+		
+		statechart->getDefaultSCI()->set_c2(false);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_e1_transition());
+		
+		
 }
-TEST_F(TriggerExpressionPrecedenceTest, unsatisfiedTriggerAndFGuardTrueOrFalse) {
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->set_c1(true);
-	
-	statechart->getDefaultSCI()->set_c2(false);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_e1_transition());
-	
+	TEST_F(TriggerExpressionPrecedenceTest, unsatisfiedTriggerAndFGuardTrueOrFalse) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->set_c1(true);
+		
+		statechart->getDefaultSCI()->set_c2(false);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_e1_transition());
+		
+		
 }
-TEST_F(TriggerExpressionPrecedenceTest, unsatisfiedTriggerAndFGuardFalseOrTrue) {
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->set_c1(false);
-	
-	statechart->getDefaultSCI()->set_c2(true);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_e1_transition());
-	
+	TEST_F(TriggerExpressionPrecedenceTest, unsatisfiedTriggerAndFGuardFalseOrTrue) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->set_c1(false);
+		
+		statechart->getDefaultSCI()->set_c2(true);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_e1_transition());
+		
+		
 }
-TEST_F(TriggerExpressionPrecedenceTest, unsatisfiedTriggerAndFGuardTrueOrTrue) {
-	
-	statechart->enter();
-	
-	statechart->getDefaultSCI()->set_c1(true);
-	
-	statechart->getDefaultSCI()->set_c2(true);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(!statechart->getDefaultSCI()->get_e1_transition());
-	
+	TEST_F(TriggerExpressionPrecedenceTest, unsatisfiedTriggerAndFGuardTrueOrTrue) {
+		
+		statechart->enter();
+		
+		statechart->getDefaultSCI()->set_c1(true);
+		
+		statechart->getDefaultSCI()->set_c2(true);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(!statechart->getDefaultSCI()->get_e1_transition());
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "TriggerGuardExpressions.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static TriggerGuardExpressions* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class TriggerGuardExpressionsTest : public ::testing::Test{
 	protected:
+	
+	TriggerGuardExpressions* statechart;
+	
 	virtual void SetUp() {
 		statechart = new TriggerGuardExpressions();
 		statechart->init();
@@ -27,72 +28,75 @@ class TriggerGuardExpressionsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(TriggerGuardExpressionsTest, trueGuard) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	statechart->getDefaultSCI()->set_b(true);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_B));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_e2();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_B));
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
 	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	statechart->getDefaultSCI()->raise_e2();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_B));
 	
+};
+
+	TEST_F(TriggerGuardExpressionsTest, trueGuard) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		statechart->getDefaultSCI()->set_b(true);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_B));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_e2();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_B));
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		statechart->getDefaultSCI()->raise_e2();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_B));
+		
+		
 }
-TEST_F(TriggerGuardExpressionsTest, falseGuard) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
-	
-	statechart->getDefaultSCI()->set_b(false);
-	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_e2();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
-	
-	statechart->getDefaultSCI()->raise_e1();
-	
-	statechart->getDefaultSCI()->raise_e2();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
-	
+	TEST_F(TriggerGuardExpressionsTest, falseGuard) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
+		
+		statechart->getDefaultSCI()->set_b(false);
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_e2();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
+		
+		statechart->getDefaultSCI()->raise_e1();
+		
+		statechart->getDefaultSCI()->raise_e2();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TriggerGuardExpressions::main_region_A));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "TypeAlias.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static TypeAlias* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class TypeAliasTest : public ::testing::Test{
 	protected:
+	
+	TypeAlias* statechart;
+	
 	virtual void SetUp() {
 		statechart = new TypeAlias();
 		statechart->init();
@@ -27,31 +28,33 @@ class TypeAliasTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(TypeAliasTest, TypeAliasTest) {
-	
-	statechart->enter();
-	
-	EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_Start));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myVar()== 1l);
 	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_Mid));
-	
-	EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "TypeSystem") == 0);
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_Mid2));
-	
-	statechart->getDefaultSCI()->raise_myEvent();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_End));
 	
+};
+
+	TEST_F(TypeAliasTest, TypeAliasTest) {
+		
+		statechart->enter();
+		
+		EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_Start));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myVar()== 1l);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_Mid));
+		
+		EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "TypeSystem") == 0);
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_Mid2));
+		
+		statechart->getDefaultSCI()->raise_myEvent();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(TypeAlias::main_region_End));
+		
+		
 }

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

@@ -4,16 +4,17 @@
 #include "ValuedEvents.h"
 #include "sc_runner.h"
 #include "sc_types.h"
+			
 
 
-
-static ValuedEvents* statechart;
-
 //! The timers are managed by a timer service. */
 static SctUnitRunner * runner;
 
 class ValuedEventsTest : public ::testing::Test{
 	protected:
+	
+	ValuedEvents* statechart;
+	
 	virtual void SetUp() {
 		statechart = new ValuedEvents();
 		statechart->init();
@@ -27,41 +28,43 @@ class ValuedEventsTest : public ::testing::Test{
 		delete statechart;
 		delete runner;
 	}
-};
-
-
-TEST_F(ValuedEventsTest, valuedEventsTest) {
-	
-	statechart->enter();
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "sct") == 0);
-	
-	statechart->getDefaultSCI()->raise_integerEvent( 23l);
-	
-	statechart->getDefaultSCI()->raise_booleanEvent( false);
 	
-	statechart->getDefaultSCI()->raise_realEvent( 20l);
-	
-	statechart->getDefaultSCI()->raise_stringEvent( "tool");
-	
-	runner->proceed_cycles(1);
-	
-	EXPECT_TRUE(statechart->isStateActive(ValuedEvents::integer_region_D));
-	
-	EXPECT_TRUE(statechart->isStateActive(ValuedEvents::string_region_D));
-	
-	EXPECT_TRUE(statechart->isStateActive(ValuedEvents::boolean_region_D));
-	
-	EXPECT_TRUE(statechart->isStateActive(ValuedEvents::real_region_D));
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt()== 23l);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool()== false);
-	
-	EXPECT_TRUE(statechart->getDefaultSCI()->get_myReal()== 20l);
-	
-	EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "tool") == 0);
 	
+};
+
+	TEST_F(ValuedEventsTest, valuedEventsTest) {
+		
+		statechart->enter();
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "sct") == 0);
+		
+		statechart->getDefaultSCI()->raise_integerEvent( 23l);
+		
+		statechart->getDefaultSCI()->raise_booleanEvent( false);
+		
+		statechart->getDefaultSCI()->raise_realEvent( 20l);
+		
+		statechart->getDefaultSCI()->raise_stringEvent( "tool");
+		
+		runner->proceed_cycles(1);
+		
+		EXPECT_TRUE(statechart->isStateActive(ValuedEvents::integer_region_D));
+		
+		EXPECT_TRUE(statechart->isStateActive(ValuedEvents::string_region_D));
+		
+		EXPECT_TRUE(statechart->isStateActive(ValuedEvents::boolean_region_D));
+		
+		EXPECT_TRUE(statechart->isStateActive(ValuedEvents::real_region_D));
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myInt()== 23l);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myBool()== false);
+		
+		EXPECT_TRUE(statechart->getDefaultSCI()->get_myReal()== 20l);
+		
+		EXPECT_TRUE(strcmp(statechart->getDefaultSCI()->get_myString(), "tool") == 0);
+		
+		
 }

test-plugins/org.yakindu.sct.generator.cpp.test/libraryTarget/sc_runner.h

@@ -17,7 +17,7 @@ extern "C" {
 class SctUnitRunner {
 	public:
 		SctUnitRunner(StatemachineInterface * statemachine, bool event_driven, sc_integer cycle_period);
-		~SctUnitRunner(){}
+		virtual ~SctUnitRunner(){};
 		void proceed_time(sc_integer time_ms);
 		void proceed_cycles(sc_integer cycles);
 		virtual void cancel();

test-plugins/org.yakindu.sct.generator.cpp.test/libraryTarget/sc_runner_timed.h

@@ -19,7 +19,7 @@ extern "C" {
 class TimedSctUnitRunner : public TimerInterface {
 	public:
 		TimedSctUnitRunner(StatemachineInterface * statemachine, bool event_driven, sc_integer cycle_period);
-		~TimedSctUnitRunner(){}
+		virtual ~TimedSctUnitRunner(){};
 		void proceed_time(sc_integer time_ms);
 		void proceed_cycles(sc_integer cycles);
 		virtual void setTimer(TimedStatemachineInterface* statemachine, sc_eventid event, sc_integer time_ms, sc_boolean isPeriodic);