Added tests for singleton code YAKHMI-393

TestScenarios/test-c-sgltn/InterfaceTest/CMakeLists.txt

@@ -0,0 +1,14 @@
+
+
+include_directories(../../src-gen-c-sgltn/InterfaceTest)
+
+add_executable(InterfaceTestStatemachineMain main.c)
+target_link_libraries(InterfaceTestStatemachineMain InterfaceTestStatemachine)
+
+add_test(Interface_test_default_interface_good_1 InterfaceTestStatemachineMain "1")
+add_test(Interface_test_default_interface_bad_2 InterfaceTestStatemachineMain "2")
+add_test(Interface_test_other_interface_good_3 InterfaceTestStatemachineMain "3")
+add_test(Interface_test_other_interface_bad_4 InterfaceTestStatemachineMain "4")
+add_test(Interface_test_third_interface_good_5 InterfaceTestStatemachineMain "5")
+add_test(Interface_test_third_interface_bad_6 InterfaceTestStatemachineMain "6")
+add_test(Interface_test_namespaces_7 InterfaceTestStatemachineMain "7")

TestScenarios/test-c-sgltn/InterfaceTest/main.c

@@ -0,0 +1,504 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "Timer.h"
+#include "DummyTimer.h"
+#include "InterfaceTestStatemachine.h"
+#include "InterfaceTestEvent.h"
+
+#define MAXEVENTSPERTYPE 4
+const char* stateName[6] = {"State1", "State2", "State3", "State4", "State5", "State6"};
+
+void setupStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* set up dummy Timer */
+	dummyTimer_init(dummyTimer);
+
+	/* Set up Event Pool */
+	interfaceTest_eventPool_init_heap(eventPool, MAXEVENTSPERTYPE);
+
+	/* initialize state machine */
+	interfaceTestStatemachine_init(dummyTimer, eventPool);
+
+	/* call all necessary enter functions */
+	interfaceTestStatemachine_enter();
+}
+
+void teardownStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* call all exit actions for this state machine */
+	interfaceTestStatemachine_exit();
+
+	/* free all internal memory for this state machine */
+	interfaceTestStatemachine_destruct();
+
+	/* free the timer */
+	timer_exit(dummyTimer);
+
+	/* free all events in the event pool */
+	eventPool_exit(eventPool);
+
+}
+
+/*@Test: test_default_interface good case, guard matches */
+int test_default_interface_good()
+{
+	InterfaceTestStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	integer retval;
+
+	printf("start\n");
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = interfaceTest_get_handle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: raise event1 on default interface */
+	interfaceTest_if_raise_event1();
+
+	/*@DescInfo: Initial value for the guard is 2.3, which is bigger than 0, so the transition should be taken */
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether the state is set to "State2" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State2") == 0);
+
+	/*@Desc: check if the entry event2 is raised */
+	assert( interfaceTest_if_is_event2_raised(&retval) == bool_true );
+
+	/*@Desc: check if the return value of event2 is set to 22 */
+	assert( retval == 22 );
+
+	/*@Desc: raise event1 on default interface */
+	interfaceTest_if_raise_event1();
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether state has changed back to "State1" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: check whether event2 is not raised any more */
+	assert( interfaceTest_if_is_event2_raised(&retval) == bool_false );
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_default_interface good case, guard matches */
+int test_default_interface_bad()
+{
+	InterfaceTestStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	integer retval = 55;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = interfaceTest_get_handle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: set variable var2 to -12.6 */
+	interfaceTest_if_set_var2(-12.6);
+
+	/*@Desc: raise event1 on default interface */
+	interfaceTest_if_raise_event1();
+
+	/*@DescInfo: Transition should not be taken, as guard with var2 is less than 0 */
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether the state is still set to "State1" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: check if the entry event2 is NOT raised */
+	assert( interfaceTest_if_is_event2_raised(&retval) == bool_false );
+
+	/*@Desc: check if the original retval has not been changed */
+	assert( retval == 55 );
+
+	/*@Desc: raise event1 on default interface */
+	interfaceTest_if_raise_event1();
+
+	/*@Desc: set variable var2 to 213.55 (>0) */
+	interfaceTest_if_set_var2(213.55);
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether state has changed back to "State2" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State2") == 0);
+
+	/*@Desc: check whether event2 is raised */
+	assert( interfaceTest_if_is_event2_raised(&retval) == bool_true );
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_other_interface good case, guard matches */
+int test_other_interface_good()
+{
+	InterfaceTestStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = interfaceTest_get_handle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: raise event3 on other interface */
+	interfaceTest_if_other_raise_event3();
+
+	/*@DescInfo: Initial value for the guard is var3 == 1, which is the initial value, so the transition should be taken */
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether the state is set to "State3" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State3") == 0);
+
+	/*@Desc: check if the entry event4 is raised */
+	assert( interfaceTest_if_other_is_event4_raised() == bool_true );
+
+	/*@Desc: raise event3 on other interface */
+	interfaceTest_if_other_raise_event3();
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether state has changed back to "State1" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: check whether event4 is not raised any more */
+	assert( interfaceTest_if_other_is_event4_raised() == bool_false );
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+
+/*@Test: test_default_interface good case, guard matches */
+int test_other_interface_bad()
+{
+	InterfaceTestStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = interfaceTest_get_handle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: set variable var3 to 2 in default interface */
+	interfaceTest_if_set_var3(2);
+
+	/*@Desc: raise event1 on other interface */
+	interfaceTest_if_other_raise_event3();
+
+	/*@DescInfo: Transition should not be taken, as guard with var3 is not equal 1 */
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether the state is still set to "State1" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: check if the entry event2 is NOT raised */
+	assert( interfaceTest_if_other_is_event4_raised() == bool_false );
+
+	/*@Desc: raise event1 on other interface */
+	interfaceTest_if_other_raise_event3();
+
+	/*@Desc: set variable var3 to 1 */
+	interfaceTest_if_set_var3(1);
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether state has changed back to "State2" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State3") == 0);
+
+	/*@Desc: check whether event2 is raised */
+	assert( interfaceTest_if_other_is_event4_raised() == bool_true );
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_third_interface good case, guard matches */
+int test_third_interface_good()
+{
+	InterfaceTestStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+	boolean retVal = bool_false;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = interfaceTest_get_handle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: raise event5 on other interface */
+	interfaceTest_if_third_raise_event5();
+
+	/*@Desc: set var1 to true */
+	interfaceTest_if_set_var1(bool_true);
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether the state is set to "State4" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State4") == 0);
+
+	/*@Desc: check if the entry event4 is raised */
+	assert( interfaceTest_if_third_is_event6_raised(&retVal) == bool_true );
+
+	/*@Desc: check whether returned event6 value is set to true */
+	assert( retVal == bool_true );
+
+	/*@Desc: raise event5 on other interface */
+	interfaceTest_if_third_raise_event5();
+
+	/*@Desc: set retValue to false */
+	retVal = bool_false;
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether state has changed back to "State1" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: check whether event4 is not raised any more */
+	assert( interfaceTest_if_third_is_event6_raised(&retVal) == bool_false );
+
+	/*@Desc: check whether returned event6 value is set to false */
+	assert( retVal == bool_false );
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_default_interface good case, guard matches */
+int test_third_interface_bad()
+{
+	InterfaceTestStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	boolean retVal = bool_false;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = interfaceTest_get_handle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: set variable var1 to false in default interface */
+	interfaceTest_if_set_var1(bool_false);
+
+	/*@Desc: raise event1 on third interface */
+	interfaceTest_if_third_raise_event5();
+
+	/*@DescInfo: Transition should not be taken, as guard with var3 is not equal 1 */
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether the state is still set to "State1" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: check if the entry event2 is NOT raised */
+	assert( interfaceTest_if_third_is_event6_raised(&retVal) == bool_false );
+
+	/*@Desc: raise event5 on third interface */
+	interfaceTest_if_third_raise_event5();
+
+	/*@Desc: set variable var1 to true on default interface */
+	interfaceTest_if_set_var1(bool_true);
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: check whether state has changed back to "State2" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State4") == 0);
+
+	/*@Desc: check whether event2 is raised */
+	assert( interfaceTest_if_third_is_event6_raised(&retVal) == bool_true );
+
+	/*@Desc: check whether returned event6 value is set to true */
+	assert( retVal == bool_true );
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+int test_namespaces()
+{
+	InterfaceTestStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = interfaceTest_get_handle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: check correct initialization of variable v1 */
+	assert( interfaceTest_if_other_get_v1() == 5 );
+
+	/*@Desc: set third interface variable v1 to 52.83 */
+	interfaceTest_if_third_set_v1( 52.83 );
+
+	/*@Desc: set other interface variable to 8877 */
+	interfaceTest_if_other_set_v1( 8877 );
+
+	/*@DescInfo: toogle through all states */
+
+	/*@Desc: raise event1 on default event */
+	interfaceTest_if_raise_event1();
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: raise event1 on default event */
+	interfaceTest_if_raise_event1();
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: raise event3 on default event */
+	interfaceTest_if_other_raise_event3();
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: raise event3 on default event */
+	interfaceTest_if_other_raise_event3();
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: set var1 of default interface to true */
+	interfaceTest_if_set_var1( bool_true);
+
+	/*@Desc: raise event5 on default event */
+	interfaceTest_if_third_raise_event5();
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	/*@Desc: raise event5 on default event */
+	interfaceTest_if_third_raise_event5();
+
+	/*@Desc: run an explicit cycle */
+	interfaceTestStatemachine_runCycle();
+
+	printf ("%f", interfaceTest_if_third_get_v1());
+
+	/*@Desc: check if v1 of third interface is still 52.83 */
+	assert( interfaceTest_if_third_get_v1() > 52.82 &&
+			interfaceTest_if_third_get_v1() < 52.84 );
+
+	/*@Desc: check if v1 of other interface is still 8877 */
+	assert( interfaceTest_if_other_get_v1() == 8877 );
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+int main(int argc, char** argv)
+{
+	if (argc != 2)
+		return -1;
+
+	switch (atoi(argv[1])) {
+	case 1:
+		return test_default_interface_good();
+	case 2:
+		return test_default_interface_bad();
+	case 3:
+		return test_other_interface_good();
+	case 4:
+		return test_other_interface_bad();
+	case 5:
+		return test_third_interface_good();
+	case 6:
+		return test_third_interface_bad();
+	case 7:
+		return test_namespaces();
+	}
+
+	return 0;
+
+}
+

TestScenarios/test-c-sgltn/Test_Expression/CMakeLists.txt

@@ -0,0 +1,11 @@
+
+
+include_directories(../../src-gen-c-sgltn/Test_Expression)
+
+add_executable(TestExpressionMain main.c)
+target_link_libraries(TestExpressionMain Test_ExpressionStatemachine)
+
+add_test(Expression_test_initialization_and_first_entry TestExpressionMain "1")
+add_test(Expression_test_default_other_var1 TestExpressionMain "2")
+add_test(Expression_test_default_other_var2_var3 TestExpressionMain "3")
+add_test(Expression_test_onCycle TestExpressionMain "4")

TestScenarios/test-c-sgltn/Test_Expression/main.c

@@ -0,0 +1,296 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "Timer.h"
+#include "DummyTimer.h"
+#include "Test_ExpressionStatemachine.h"
+#include "Test_ExpressionEvent.h"
+
+/*@DescTest: Expression Statechart Test (Test_Expression.sct) */
+
+#define MAXEVENTSPERTYPE 4
+const char* stateName[6] = {"State1", "State2", "State3", "State4", "State5", "State6"};
+
+void setupStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* set up dummy Timer */
+	dummyTimer_init(dummyTimer);
+
+	/* Set up Event Pool */
+	test_Expression_eventPool_init_heap(eventPool, MAXEVENTSPERTYPE);
+
+	/* initialize state machine */
+	test_ExpressionStatemachine_init(dummyTimer, eventPool);
+
+	/* call all necessary enter functions */
+	test_ExpressionStatemachine_enter();
+}
+
+void teardownStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* call all exit actions for this state machine */
+	test_ExpressionStatemachine_exit();
+
+	/* free all internal memory for this state machine */
+	test_ExpressionStatemachine_destruct();
+
+	/* free the timer */
+	timer_exit(dummyTimer);
+
+	/* free all events in the event pool */
+	eventPool_exit(eventPool);
+
+}
+
+/*@Test: test_default_var1 test behavior of var1 in default interface */
+int test_initialization_and_first_entry()
+{
+//	Test_ExpressionStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	real testvalue1u = (19.4 + 19.4*123 + 0.1);
+	real testvalue1l = (19.4 + 19.4*123 - 0.1);
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+//	machine = test_Expression_get_handle();
+
+	/*@Desc: check whether var1 from default interface is initially set to 6 */
+	assert( test_Expression_if_get_var1() == 6);
+
+	/*@Desc: check whether var2 from default is initially set to 123 */
+	assert( test_Expression_if_get_var2() == 123);
+
+	/*@Desc: check, wether var3 from default interface is set correct after state1 entry */
+	printf("Var3 is set to %f\n", test_Expression_if_get_var3());
+	assert( (test_Expression_if_get_var3() > testvalue1l) &&
+			(test_Expression_if_get_var3() < testvalue1u) );
+
+	/*@Desc: check, whether var4 from default interface is between 43.3 and 43.5 */
+	printf("Var4 is set to %f\n", test_Expression_if_get_var4());
+	assert( (test_Expression_if_get_var4() > 43.2) &&
+			(test_Expression_if_get_var4() < 43.4) );
+
+	/*@Desc: check whether var5 from default interface is initially set to false */
+	assert( test_Expression_if_get_var5() == bool_false);
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+
+}
+
+
+
+
+/*@Test: test_default_var1 test behavior of var1 in default and other interface */
+int test_default_other_var1()
+{
+	Test_ExpressionStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Expression_get_handle();
+
+	/*@Desc: check initial value for var1 ( == 6) */
+	assert( test_Expression_if_get_var1() == 6 );
+
+	/*@Desc: run an explicit cycle - without any waiting event */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: check value for var1 after state1 entry / var1 is not changed during entry into state1 */
+	assert( test_Expression_if_get_var1() == 6 );
+
+	/*@Desc: raise event1 on default interface with value 5 (actually unused) */
+	test_Expression_if_raise_event1(5);
+
+	/*@Desc: set other.var1 to "true" to let transition take place */
+	test_Expression_if_other_set_var1(bool_true);
+
+	/*@Desc: run an explicit cycle */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: check whether the state is set to "State2" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State2") == 0);
+
+	/*@Desc: check whether the transition action was executed */
+	assert( test_Expression_if_other_get_var1() == bool_false);
+
+	/*@Desc: check whether var1 has been increased by 1 (==7) */
+	assert( test_Expression_if_get_var1() == 7 );
+
+	/*@Desc: run an explicit cycle */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: check whether the state is still set to "State2" */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State2") == 0);
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+int test_default_other_var2_var3()
+{
+	Test_ExpressionStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	real testvalue1u = (19.4 + 19.4*123 + 0.1);
+	real testvalue1l = (19.4 + 19.4*123 - 0.1);
+
+	real testvalue2u = (19.4 + 19.4*123)/5.0 + 0.1;
+	real testvalue2l = (19.4 + 19.4*123)/5.0 - 0.1;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Expression_get_handle();
+
+	/*@Desc: check initial value for var2 ( == 123) */
+	assert( test_Expression_if_get_var2() == 123 );
+
+	/*@Desc: check initial value for var3 (19.4) */
+	printf("Var3 is set to %f\n", test_Expression_if_get_var3());
+	assert( (test_Expression_if_get_var3() > testvalue1l) &&
+			(test_Expression_if_get_var3() < testvalue1u));
+
+	/*@Desc: run an explicit cycle - without any waiting event */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc: raise event1 on default interface with value 5 (actually unused) */
+	test_Expression_if_raise_event1(5);
+
+	/*@Desc: run an explicit cycle - without any waiting event */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State2") == 0);
+
+
+	/*@Desc: check, wether var3 on default interface is set correct after state1 entry */
+	assert( test_Expression_if_get_var2() == 1 );
+
+	/*@Desc: set var5 to "false" to let transition take place */
+	test_Expression_if_set_var5(bool_false);
+
+	/*@Desc: raise event1 on default interface with value 5 (actually unused) */
+	test_Expression_if_raise_event1(5);
+
+	/*@Desc: check the initial state */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State2") == 0);
+
+	/*@Desc: check, wether var3 on default interface is set correct after entry */
+	printf("Var3 is set to %f\n", test_Expression_if_get_var3());
+	assert( (test_Expression_if_get_var3() > testvalue2l) &&
+			(test_Expression_if_get_var3() < testvalue2u) );
+
+	/*@Desc: set event1 with variable 5 (acutally unused) */
+	test_Expression_if_raise_event1(5);
+
+	/*@Desc: run an explicit cycle */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: check the transition to state1 */
+	printf("%s\n", stateName[statemachineBase_getState((StatemachineBase*)machine, 0)]);
+	assert( strcmp(stateName[statemachineBase_getState((StatemachineBase*)machine, 0)], "State1") == 0);
+
+	/*@Desc-Info: I will not calculate the complete for var3 in this scenario */
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+int test_onCycle()
+{
+//	Test_ExpressionStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+//	machine = test_Expression_get_handle();
+
+	/*@Desc: run an explicit cycle - without any waiting event */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: raise event1 on default interface with value 5 (actually unused) */
+	test_Expression_if_raise_event1(5);
+
+	/*@Desc: set other.var1 to "true" to let transition take place */
+	test_Expression_if_other_set_var1(bool_true);
+
+	/*@Desc: run an explicit cycle */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: check whether var1 has been increased by one (==7) */
+	assert( test_Expression_if_get_var1() == 7 );
+
+	/*@Desc: run an explicit cycle - without any change */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: check whether var1 has been increased by 1 on onCycle (==8) */
+	assert( test_Expression_if_get_var1() == 8 );
+
+	/*@Desc: run an explicit cycle - without any change */
+	test_ExpressionStatemachine_runCycle();
+
+	/*@Desc: check whether var1 has been increased by 1 on onCycle (==9) */
+	assert( test_Expression_if_get_var1() == 9 );
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+
+
+int main(int argc, char** argv)
+{
+	if (argc != 2)
+		return -1;
+
+	switch (atoi(argv[1])) {
+	case 1:
+		return test_initialization_and_first_entry();
+	case 2:
+		return test_default_other_var1();
+	case 3:
+		return test_default_other_var2_var3();
+	case 4:
+		return test_onCycle();
+	}
+
+	return 0;
+
+}
+

TestScenarios/test-c-sgltn/Test_Hierarchy/CMakeLists.txt

@@ -0,0 +1,13 @@
+include_directories(../../src-gen-c-sgltn/Test_Hierarchy)
+
+add_executable(TestHierarchyMain main.c)
+target_link_libraries(TestHierarchyMain Test_HierarchyStatemachine)
+
+add_test(Hierarchy_test_state9_state10_transition TestHierarchyMain "1")
+add_test(Hierarchy_test_state1_state2_back_transition TestHierarchyMain "2")
+add_test(Hierarchy_traverse_to_State5_back_with_event6_transition TestHierarchyMain "3")
+add_test(Hierarchy_traverse_to_State5_back_with_event15_transition TestHierarchyMain "4")
+add_test(Hierarchy_state2_back_with_event14_transition TestHierarchyMain "5")
+add_test(Hierarchy_traverse_to_State7_back_with_event6_transition TestHierarchyMain "6")
+add_test(Hierarchy_traverse_to_State8_back_with_event6_transition TestHierarchyMain "7")
+add_test(Hierarchy_traverse_to_State8_back_with_event16_transition TestHierarchyMain "8")

TestScenarios/test-c-sgltn/Test_Hierarchy/main.c

@@ -0,0 +1,691 @@
+/*
+ * main.c
+ *
+ *  Created on: 16.11.2011
+ *      Author: showcase
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "Timer.h"
+#include "DummyTimer.h"
+#include "Test_HierarchyStatemachine.h"
+
+/*@DTestSuite: Hierachy Statechart Test (Test_Hierarchy.sct) */
+
+#define MAXEVENTSPERTYPE 4
+const char* stateName[13] = {"State1", "State2", "State3", "State4", "State5", "State6", "State7", "State8", "State9", "State10", "State11", "State12", "none"};
+const int EnumTostateStr[10] = { _State1, _State2, _State3, _State4, _State5, _State6, _State7, _State8, _State9, _State10 };
+
+const char* getStateString(uint32_t index)
+{
+	int i;
+	for (i=0; i<10; ++i)
+		if (EnumTostateStr[i] == index)
+			return stateName[i];
+	return stateName[12];
+}
+
+void setupStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* set up dummy Timer */
+	dummyTimer_init(dummyTimer);
+
+	/* Set up Event Pool */
+	test_Hierarchy_eventPool_init_heap(eventPool, MAXEVENTSPERTYPE);
+
+	/* initialize state machine */
+	test_HierarchyStatemachine_init(dummyTimer, eventPool);
+
+	/* call all necessary enter functions */
+	test_HierarchyStatemachine_enter();
+
+}
+
+void teardownStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* call all exit actions for this state machine */
+	test_HierarchyStatemachine_exit();
+
+	/* free all internal memory for this state machine */
+	test_HierarchyStatemachine_destruct();
+
+	/* free the timer */
+	timer_exit(dummyTimer);
+
+	/* free all events in the event pool */
+	eventPool_exit(eventPool);
+
+}
+
+/*@Test: test_state9_state10_transition test behavior of var1 in default and other interface */
+int test_state9_state10_transition()
+{
+	Test_HierarchyStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Hierarchy_get_handle();
+
+	/*@Desc: check wether state is initial state (State9) */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is still in initial state (State9) */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: raise event9 on default interface */
+	test_Hierarchy_if_raise_event9();
+
+	/*@Desc: run the statechart to trigger state change */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state10 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State10") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: raise event10 on default interface */
+	test_Hierarchy_if_raise_event10();
+
+	/*@Desc: run the statechart to trigger state change */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state10 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_state1_state2_back_transition test of event1 raised on default interface to enter state 3 */
+int test_state1_state2_back_transition()
+{
+	Test_HierarchyStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Hierarchy_get_handle();
+
+	/*@Desc: check wether state is initial state (State9) */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: raise event1 on default interface */
+	test_Hierarchy_if_raise_event1();
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state3 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State3") == 0);
+
+	/*@Desc: check whether s2 is set to 2 as State 3 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s2() == 2 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 0 );
+
+	/*@Desc: raise event6 on default interface */
+	test_Hierarchy_if_raise_event6();
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state10 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s2 is set to 2 as State 3 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s2() == 0 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_state1_state2_back_transition test of event1 raised on default interface to enter state 3 */
+int test_state1_state2_back_with_event14_transition()
+{
+	Test_HierarchyStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Hierarchy_get_handle();
+
+	/*@Desc: check wether state is initial state (State9) */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: raise event1 on default interface */
+	test_Hierarchy_if_raise_event1();
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state3 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State3") == 0);
+
+	/*@Desc: check whether s2 is set to 2 as State 3 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s2() == 2 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 0 );
+
+	/*@Desc: raise event6 on default interface */
+	test_Hierarchy_if_raise_event14();
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state10 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s2 is set to 2 as State 3 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s2() == 0 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+
+/*@Test: test_traverse_to_State5_back_with_event6_transition tests whether transition to state5 and back to state9 works correct */
+int test_traverse_to_State5_back_with_event6_transition()
+{
+	Test_HierarchyStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Hierarchy_get_handle();
+
+	/*@Desc: check wether state is initial state (State9) */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: raise event1 on default interface */
+	test_Hierarchy_if_raise_event1();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state3 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State3") == 0);
+
+	/*@Desc: raise event2 on default interface */
+	test_Hierarchy_if_raise_event2();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state3 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State5") == 0);
+
+
+	/*@Desc: check whether s2 is set to 3 as State 5 is in third hierarchy level */
+	assert( test_Hierarchy_if_get_s2() == 3 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 0 );
+
+	/*@Desc: raise event6 on default interface */
+	test_Hierarchy_if_raise_event6();
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state10 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s2 is set to 2 as State 3 is in second hierarchy level */
+	printf( " s2 = %d\n", test_Hierarchy_if_get_s2());
+	assert( test_Hierarchy_if_get_s2() == 0 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+
+/*@Test: test_default_var1 test behavior of var1 in default and other interface */
+int test_traverse_to_State5_back_with_event15_transition()
+{
+	Test_HierarchyStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Hierarchy_get_handle();
+
+	/*@Desc: check wether state is initial state (State9) */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: raise event1 on default interface */
+	test_Hierarchy_if_raise_event1();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state3 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State3") == 0);
+
+	/*@Desc: raise event2 on default interface */
+	test_Hierarchy_if_raise_event2();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state3 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State5") == 0);
+
+
+	/*@Desc: check whether s2 is set to 3 as State 5 is in third hierarchy level */
+	assert( test_Hierarchy_if_get_s2() == 3 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 0 );
+
+	/*@Desc: raise event6 on default interface */
+	test_Hierarchy_if_raise_event15();
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state10 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State10") == 0);
+
+	/*@Desc: check whether s2 is set to 2 as State 3 is in second hierarchy level */
+	printf( " s2 = %d\n", test_Hierarchy_if_get_s2());
+	assert( test_Hierarchy_if_get_s2() == 0 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_traverse_to_State7_back_with_event6_transition tests whether transition to state7 and back to state9 works correct */
+int test_traverse_to_State7_back_with_event6_transition()
+{
+	Test_HierarchyStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Hierarchy_get_handle();
+
+	/*@Desc: check wether state is initial state (State9) */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: raise event1 on default interface */
+	test_Hierarchy_if_raise_event1();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state3 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State3") == 0);
+
+	/*@Desc: raise event2 on default interface */
+	test_Hierarchy_if_raise_event2();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state5 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State5") == 0);
+
+	/*@Desc: raise event2 on default interface */
+	test_Hierarchy_if_raise_event3();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state7 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State7") == 0);
+
+	/*@Desc: check whether s2 is set to 3 as State 7 is in 4th hierarchy level */
+	assert( test_Hierarchy_if_get_s2() == 4 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 0 );
+
+	/*@Desc: raise event6 on default interface */
+	test_Hierarchy_if_raise_event6();
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state9 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s2 is set to 2 as State 3 is in second hierarchy level */
+	printf( " s2 = %d\n", test_Hierarchy_if_get_s2());
+	assert( test_Hierarchy_if_get_s2() == 0 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_traverse_to_State8_back_with_event6_transition tests whether transition to state8 and back to state9 works correct */
+int test_traverse_to_State8_back_with_event6_transition()
+{
+	Test_HierarchyStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Hierarchy_get_handle();
+
+	/*@Desc: check wether state is initial state (State9) */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: raise event1 on default interface */
+	test_Hierarchy_if_raise_event1();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state3 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State3") == 0);
+
+	/*@Desc: raise event2 on default interface */
+	test_Hierarchy_if_raise_event2();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state5 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State5") == 0);
+
+	/*@Desc: raise event3 on default interface */
+	test_Hierarchy_if_raise_event3();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state7 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State7") == 0);
+
+	/*@Desc: raise event4 on default interface */
+	test_Hierarchy_if_raise_event4();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state8 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State8") == 0);
+
+	/*@Desc: check whether s2 is set to 3 as State 7 is in 4th hierarchy level */
+	assert( test_Hierarchy_if_get_s2() == 4 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 0 );
+
+	/*@Desc: raise event6 on default interface */
+	test_Hierarchy_if_raise_event6();
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state9 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s2 is set to 2 as State 3 is in second hierarchy level */
+	printf( " s2 = %d\n", test_Hierarchy_if_get_s2());
+	assert( test_Hierarchy_if_get_s2() == 0 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_traverse_to_State8_back_with_event16_transition tests whether transition to state8 and back to state10 works correct */
+int test_traverse_to_State8_back_with_event16_transition()
+{
+	Test_HierarchyStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+	machine = test_Hierarchy_get_handle();
+
+	/*@Desc: check wether state is initial state (State9) */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State9") == 0);
+
+	/*@Desc: check whether s1 is set to 2 as State 9 is in second hierarchy level */
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+	/*@Desc: raise event1 on default interface */
+	test_Hierarchy_if_raise_event1();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state3 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State3") == 0);
+
+	/*@Desc: raise event2 on default interface */
+	test_Hierarchy_if_raise_event2();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state5 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State5") == 0);
+
+	/*@Desc: raise event3 on default interface */
+	test_Hierarchy_if_raise_event3();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state7 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State7") == 0);
+
+	/*@Desc: raise event4 on default interface */
+	test_Hierarchy_if_raise_event4();
+
+	/*@Desc: run the statechart cycle */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state8 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State8") == 0);
+
+	/*@Desc: check whether s2 is set to 3 as State 7 is in 4th hierarchy level */
+	assert( test_Hierarchy_if_get_s2() == 4 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 0 );
+
+	/*@Desc: raise event16 on default interface */
+	test_Hierarchy_if_raise_event16();
+
+	/*@Desc: run the statechart for the first time (just as dummy) */
+	test_HierarchyStatemachine_runCycle();
+
+	/*@Desc: check wether state is changed  to state10 */
+	printf("%s\n", getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)));
+	assert( strcmp(getStateString(statemachineBase_getState((StatemachineBase*)machine, 0)), "State10") == 0);
+
+	/*@Desc: check whether s2 is set to 2 as State 3 is in second hierarchy level */
+	printf( " s2 = %d\n", test_Hierarchy_if_get_s2());
+	assert( test_Hierarchy_if_get_s2() == 0 );
+
+	/*@Desc: check whether s1 is set to 0 as State 1 has been left */
+	printf( " s1 = %d\n", test_Hierarchy_if_get_s1());
+	assert( test_Hierarchy_if_get_s1() == 2 );
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+
+
+int main(int argc, char** argv)
+{
+	if (argc != 2)
+		return -1;
+
+	switch (atoi(argv[1])) {
+	case 1:
+		return test_state9_state10_transition();
+	case 2:
+		return test_state1_state2_back_transition();
+	case 3:
+		return test_traverse_to_State5_back_with_event6_transition();
+	case 4:
+		return test_traverse_to_State5_back_with_event15_transition();
+	case 5:
+		return test_state1_state2_back_with_event14_transition();
+	case 6:
+		return test_traverse_to_State7_back_with_event6_transition();
+	case 7:
+		return test_traverse_to_State8_back_with_event6_transition();
+	case 8:
+		return test_traverse_to_State8_back_with_event16_transition();
+	}
+
+
+	return -1;
+
+}

TestScenarios/test-c-sgltn/Test_LocalActions/CMakeLists.txt

@@ -0,0 +1,8 @@
+include_directories(../../src-gen-c-sgltn/Test_LocalActions)
+
+add_executable(TestLocalActionsMain main.c)
+target_link_libraries(TestLocalActionsMain Test_LocalActionsStatemachine)
+
+add_test(Dummy1 TestLocalActionsMain "1")
+add_test(Dummy2 TestLocalActionsMain "2")
+

TestScenarios/test-c-sgltn/Test_LocalActions/main.c

@@ -0,0 +1,125 @@
+/*
+ * main.c
+ *
+ *  Created on: 16.11.2011
+ *      Author: showcase
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "Timer.h"
+#include "DummyTimer.h"
+#include "Test_LocalActionsStatemachine.h"
+
+/*@DTestSuite: LocalActions Statechart Test (Test_LocalActions.sct) */
+
+#define MAXEVENTSPERTYPE 4
+const char* stateName[6] = {"State1", "State2", "State3", "State4", "State5", "State6"};
+
+void setupStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* set up dummy Timer */
+	dummyTimer_init(dummyTimer);
+
+	/* Set up Event Pool */
+	test_LocalActions_eventPool_init_heap(eventPool, MAXEVENTSPERTYPE);
+
+	/* initialize state machine */
+	test_LocalActionsStatemachine_init(dummyTimer, eventPool);
+
+	/* call all necessary enter functions */
+	test_LocalActionsStatemachine_enter();
+
+}
+
+void teardownStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* call all exit actions for this state machine */
+	test_LocalActionsStatemachine_exit();
+
+	/* free all internal memory for this state machine */
+	test_LocalActionsStatemachine_destruct();
+
+	/* free the timer */
+	timer_exit(dummyTimer);
+
+	/* free all events in the event pool */
+	eventPool_exit(eventPool);
+
+}
+
+/*@Test: test_default_var1 test behavior of var1 in default interface */
+int test_initialization()
+{
+
+	return 0;
+}
+
+
+/*@Test: test_state9_state10_transition test behavior of var1 in default and other interface */
+int dummy1()
+{
+//	Test_LocalActionsStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+//	machine = test_LocalActions_get_handle();
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_default_var1 test behavior of var1 in default and other interface */
+int dummy2()
+{
+//	Test_LocalActionsStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+//	machine = test_LocalActions_get_handle();
+
+	/*@Desc: run an explicit cycle - without any waiting event (for initialization) */
+	test_LocalActionsStatemachine_runCycle();
+
+	/*@Desc:  */
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+
+
+
+
+
+int main(int argc, char** argv)
+{
+	if (argc != 2)
+		return -1;
+
+	switch (atoi(argv[1])) {
+	case 1:
+		return dummy1();
+	case 2:
+		return dummy2();
+	}
+
+	return -1;
+
+}

TestScenarios/test-c-sgltn/Test_ParallelRegions/CMakeLists.txt

@@ -0,0 +1,8 @@
+include_directories(../../src-gen-c-sgltn/Test_ParallelRegions)
+
+add_executable(TestParallelRegionsMain main.c)
+target_link_libraries(TestParallelRegionsMain Test_ParallelRegionsStatemachine)
+
+add_test(Dummy1 TestParallelRegionsMain "1")
+add_test(Dummy2 TestParallelRegionsMain "2")
+

TestScenarios/test-c-sgltn/Test_ParallelRegions/main.c

@@ -0,0 +1,117 @@
+/*
+ * main.c
+ *
+ *  Created on: 16.11.2011
+ *      Author: showcase
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "Timer.h"
+#include "DummyTimer.h"
+#include "Test_ParallelRegionsStatemachine.h"
+
+/*@DTestSuite: ParallelRegions Statechart Test (Test_ParallelRegions.sct) */
+
+#define MAXEVENTSPERTYPE 4
+const char* stateName[6] = {"State1", "State2", "State3", "State4", "State5", "State6"};
+
+void setupStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* set up dummy Timer */
+	dummyTimer_init(dummyTimer);
+
+	/* Set up Event Pool */
+	test_ParallelRegions_eventPool_init_heap(eventPool, MAXEVENTSPERTYPE);
+
+	/* initialize state machine */
+	test_ParallelRegionsStatemachine_init(dummyTimer, eventPool);
+
+	/* call all necessary enter functions */
+	test_ParallelRegionsStatemachine_enter();
+
+}
+
+void teardownStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* call all exit actions for this state machine */
+	test_ParallelRegionsStatemachine_exit();
+
+	/* free all internal memory for this state machine */
+	test_ParallelRegionsStatemachine_destruct();
+
+	/* free the timer */
+	timer_exit(dummyTimer);
+
+	/* free all events in the event pool */
+	eventPool_exit(eventPool);
+
+}
+
+/*@Test: test_state9_state10_transition test behavior of var1 in default and other interface */
+int dummy1()
+{
+//	Test_ParallelRegionsStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+//	machine = test_ParallelRegions_get_handle();
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_default_var1 test behavior of var1 in default and other interface */
+int dummy2()
+{
+//	Test_ParallelRegionsStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+//	machine = test_ParallelRegions_get_handle();
+
+	/*@Desc: run an explicit cycle - without any waiting event (for initialization) */
+	test_ParallelRegionsStatemachine_runCycle();
+
+	/*@Desc:  */
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+
+
+
+
+
+int main(int argc, char** argv)
+{
+	if (argc != 2)
+		return -1;
+
+	switch (atoi(argv[1])) {
+	case 1:
+		return dummy1();
+	case 2:
+		return dummy2();
+	}
+
+	return -1;
+
+}

TestScenarios/test-c-sgltn/Test_ShallowHistory/CMakeLists.txt

@@ -0,0 +1,8 @@
+include_directories(../../src-gen-c-sgltn/Test_ShallowHistory)
+
+add_executable(TestShallowHistoryMain main.c)
+target_link_libraries(TestShallowHistoryMain Test_ShallowHistoryStatemachine)
+
+add_test(Dummy1 TestShallowHistoryMain "1")
+add_test(Dummy2 TestShallowHistoryMain "2")
+

TestScenarios/test-c-sgltn/Test_ShallowHistory/main.c

@@ -0,0 +1,119 @@
+/*
+ * main.c
+ *
+ *  Created on: 16.11.2011
+ *      Author: showcase
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "Timer.h"
+#include "DummyTimer.h"
+#include "Test_ShallowHistoryStatemachine.h"
+
+/*@DTestSuite: ShallowHistory Statechart Test (Test_ShallowHistory.sct) */
+
+#define MAXEVENTSPERTYPE 4
+const char* stateName[6] = {"State1", "State2", "State3", "State4", "State5", "State6"};
+
+void setupStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* set up dummy Timer */
+	dummyTimer_init(dummyTimer);
+
+	/* Set up Event Pool */
+	test_ShallowHistory_eventPool_init_heap(eventPool, MAXEVENTSPERTYPE);
+
+	/* initialize state machine */
+	test_ShallowHistoryStatemachine_init(dummyTimer, eventPool);
+
+	/* call all necessary enter functions */
+	test_ShallowHistoryStatemachine_enter();
+
+}
+
+void teardownStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* call all exit actions for this state machine */
+	test_ShallowHistoryStatemachine_exit();
+
+	/* free all internal memory for this state machine */
+	test_ShallowHistoryStatemachine_destruct();
+
+	/* free the timer */
+	timer_exit(dummyTimer);
+
+	/* free all events in the event pool */
+	eventPool_exit(eventPool);
+
+}
+
+/*@Test: test_state9_state10_transition test behavior of var1 in default and other interface */
+int dummy1()
+{
+//	Test_ShallowHistoryStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/* get the handle only for getting the state name */
+//	machine = test_ShallowHistory_get_handle()();
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_default_var1 test behavior of var1 in default and other interface */
+int dummy2()
+{
+//	Test_ShallowHistoryStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+	/*@Desc: run an explicit cycle - without any waiting event (for initialization) */
+	test_ShallowHistoryStatemachine_runCycle();
+
+	/* get the handle only for getting the state name */
+//	machine = test_ShallowHistory_get_handle()();
+
+
+	/*@Desc:  */
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+
+
+
+
+
+int main(int argc, char** argv)
+{
+	if (argc != 2)
+		return -1;
+
+	switch (atoi(argv[1])) {
+	case 1:
+		return dummy1();
+	case 2:
+		return dummy2();
+	}
+
+	return -1;
+
+}

TestScenarios/test-c-sgltn/Test_Transition/CMakeLists.txt

@@ -0,0 +1,8 @@
+include_directories(../../src-gen-c-sgltn/Test_Transition)
+
+add_executable(TestTransitionMain main.c)
+target_link_libraries(TestTransitionMain Test_TransitionStatemachine)
+
+add_test(d_test_state9_state10_transition TestTransitionMain "1")
+add_test(d_test_state1_state2_back_transition TestTransitionMain "2")
+

TestScenarios/test-c-sgltn/Test_Transition/main.c

@@ -0,0 +1,120 @@
+/*
+ * main.c
+ *
+ *  Created on: 16.11.2011
+ *      Author: showcase
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "Timer.h"
+#include "DummyTimer.h"
+#include "Test_TransitionStatemachine.h"
+
+/*@DTestSuite: Hierachy Statechart Test (Test_Transition.sct) */
+
+#define MAXEVENTSPERTYPE 4
+const char* stateName[6] = {"State1", "State2", "State3", "State4", "State5", "State6"};
+
+void setupStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* set up dummy Timer */
+	dummyTimer_init(dummyTimer);
+
+	/* Set up Event Pool */
+	test_Transition_eventPool_init_heap(eventPool, MAXEVENTSPERTYPE);
+
+	/* initialize state machine */
+	test_TransitionStatemachine_init(dummyTimer, eventPool);
+
+	/* call all necessary enter functions */
+	test_TransitionStatemachine_enter();
+
+}
+
+void teardownStatemachine(Timer* dummyTimer, EventPool* eventPool)
+{
+	/* call all exit actions for this state machine */
+	test_TransitionStatemachine_exit();
+
+	/* free all internal memory for this state machine */
+	test_TransitionStatemachine_destruct();
+
+	/* free the timer */
+	timer_exit(dummyTimer);
+
+	/* free all events in the event pool */
+	eventPool_exit(eventPool);
+
+}
+
+
+/*@Test: test_state9_state10_transition test behavior of var1 in default and other interface */
+int test_state9_state10_transition()
+{
+//	Test_TransitionStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+//	machine = test_Transition_get_handle();
+
+	/*@Desc: run the statechart for the first time (initially) */
+	test_TransitionStatemachine_runCycle();
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+/*@Test: test_default_var1 test behavior of var1 in default and other interface */
+int test_state1_state2_back_transition()
+{
+//	Test_TransitionStatemachine* machine;
+	Timer dummyTimer;
+	EventPool eventPool;
+
+	/*@Desc: setup initial statemachine */
+	setupStatemachine(&dummyTimer, &eventPool);
+
+//	machine = test_Transition_get_handle();
+
+	/*@Desc: run an explicit cycle - without any waiting event (for initialization) */
+	test_TransitionStatemachine_runCycle();
+
+	/*@Desc:  */
+
+
+	/*@Desc: teardown statemachine */
+	teardownStatemachine(&dummyTimer, &eventPool);
+
+	return 0;
+}
+
+
+
+
+
+
+int main(int argc, char** argv)
+{
+	if (argc != 2)
+		return -1;
+
+	switch (atoi(argv[1])) {
+	case 1:
+		return test_state9_state10_transition();
+	case 2:
+		return test_state1_state2_back_transition();
+	}
+
+	return -1;
+
+}