| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // Copyright (c) 2000-2019 Ericsson Telecom AB // |
| // // |
| // All rights reserved. This program and the accompanying materials // |
| // are made available under the terms of the Eclipse Public License v2.0 // |
| // which accompanies this distribution, and is available at // |
| // https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////// |
| // Module: EPTF_Base_Test_Functions |
| // |
| // Purpose: |
| // This module contains functions for testing EPTF Base. |
| // |
| // Module Parameters: |
| // - |
| // Module depends on: |
| // <EPTF_Base_Test_Definitions> |
| // <EPTF_CLL_Base_Functions> |
| // |
| // Current Owner: |
| // Balazs Barcsik (ebalbar) |
| // |
| // Last Review Date: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| /////////////////////////////////////////////////////////// |
| module EPTF_Base_Test_Functions { |
| |
| //========================================================================= |
| // Import Part |
| //========================================================================= |
| import from EPTF_CLL_Base_Definitions all; |
| import from EPTF_Base_Test_Definitions all; |
| import from EPTF_CLL_Base_Functions all; |
| |
| //========================================================================= |
| // Functions |
| //========================================================================= |
| // mandatory functions for A_CT: |
| |
| function f_A_init_CT(in charstring pl_selfName /* your additional input parameters */) runs on A_CT { |
| if (v_A_initialized) { |
| return; |
| } |
| |
| // call all the init functions of the components that your component extends _explicitly_: |
| f_EPTF_Base_init_CT(pl_selfName /*additional parameters*/); |
| |
| // initialize your component variables here... |
| v_A_Var := 0; |
| |
| v_A_initialized := true; |
| |
| // register your cleanup function: |
| f_EPTF_Base_registerCleanup(refers(f_A_cleanup_CT)); |
| |
| log("----A INIT DONE----"); |
| } |
| |
| |
| function f_A_cleanup_CT() runs on A_CT { |
| if (v_A_initialized == false) { |
| return; |
| } |
| |
| // reset your variables here if needed... |
| |
| log("A: v_A_Var: ", v_A_Var); |
| v_A_initialized := false; |
| log("----A CLEANUP DONE----"); |
| // additional cleanup functions can be called here, but better if you do not call them. Register them instead. |
| } |
| |
| function f_A_Behaviour(in charstring pl_selfName) runs on A_CT { |
| f_A_init_CT(pl_selfName); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| // mandatory functions for B_CT: |
| |
| function f_B_init_CT(in charstring pl_selfName /* your additional input parameters */) runs on B_CT { |
| if (v_B_initialized) { |
| return; |
| } |
| |
| // call all the init functions of the components that your component extends _explicitly_: |
| f_EPTF_Base_init_CT(pl_selfName /*additional parameters*/); |
| |
| // initialize your component variables here... |
| v_B_Var := 0; |
| |
| v_B_initialized := true; |
| |
| // register your cleanup function: |
| f_EPTF_Base_registerCleanup(refers(f_B_cleanup_CT)); |
| |
| log("----B INIT DONE----"); |
| } |
| |
| |
| function f_B_cleanup_CT() runs on B_CT { |
| if (v_B_initialized == false) { |
| return; |
| } |
| |
| // reset your variables here if needed... |
| |
| log("B: v_B_Var: ", v_B_Var); |
| v_B_initialized := false; |
| log("----B CLEANUP DONE----"); |
| // additional cleanup functions can be called here, but better if you do not call them. Register them instead. |
| } |
| |
| function f_B_Behaviour(in charstring pl_selfName) runs on B_CT { |
| f_B_init_CT(pl_selfName); |
| timer t_wait := 1.0; |
| t_wait.start; t_wait.timeout; |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| // mandatory functions for C_CT: |
| |
| function f_C_init_CT(in charstring pl_selfName /* your additional input parameters */) runs on C_CT { |
| if (v_C_initialized) { |
| return; |
| } |
| |
| // call all the init functions of the components that your component extends _explicitly_: |
| f_A_init_CT(pl_selfName /*additional parameters*/); |
| f_B_init_CT(pl_selfName /*additional parameters*/); |
| |
| // initialize your component variables here... |
| v_A_Var := v_A_Var + 1; |
| v_B_Var := v_B_Var + 1; |
| v_C_Var := 0; |
| |
| v_C_initialized := true; |
| |
| // register your cleanup function: |
| f_EPTF_Base_registerCleanup(refers(f_C_cleanup_CT)); |
| |
| log("----C INIT DONE----"); |
| } |
| |
| |
| function f_C_cleanup_CT() runs on C_CT { |
| if (v_C_initialized == false) { |
| return; |
| } |
| |
| // reset your variables here if needed... |
| |
| log("A: v_A_Var: ", v_A_Var); |
| log("B: v_B_Var: ", v_B_Var); |
| log("C: v_C_Var: ", v_C_Var); |
| v_C_initialized := false; |
| log("----C CLEANUP DONE----"); |
| // additional cleanup functions can be called here, but better if you do not call them. Register them instead. |
| } |
| |
| function f_C_Behaviour(in charstring pl_selfName) runs on C_CT { |
| f_C_init_CT(pl_selfName); |
| timer t_wait := 100.0; |
| t_wait.start; t_wait.timeout; |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| // mandatory functions for D_CT: |
| |
| function f_D_init_CT(in charstring pl_selfName /* your additional input parameters */) runs on D_CT { |
| if (v_D_initialized) { |
| return; |
| } |
| |
| // call all the init functions of the components that your component extends _explicitly_: |
| f_C_init_CT(pl_selfName /*additional parameters*/); |
| f_B_init_CT(pl_selfName /*additional parameters*/); |
| f_A_init_CT(pl_selfName /*additional parameters*/); |
| f_EPTF_Base_init_CT(pl_selfName); |
| |
| // initialize your component variables here... |
| v_A_Var := v_A_Var + 1; |
| v_B_Var := v_B_Var + 1; |
| v_C_Var := v_C_Var + 1; |
| v_D_Var := 0; |
| |
| v_D_initialized := true; |
| |
| // register your cleanup function: |
| f_EPTF_Base_registerCleanup(refers(f_D_cleanup_CT)); |
| |
| log("----D INIT DONE----"); |
| } |
| |
| |
| function f_D_cleanup_CT() runs on D_CT { |
| if (v_D_initialized == false) { |
| return; |
| } |
| |
| // reset your variables here if needed... |
| |
| log("A: v_A_Var: ", v_A_Var); |
| log("B: v_B_Var: ", v_B_Var); |
| log("C: v_C_Var: ", v_C_Var); |
| log("D: v_D_Var: ", v_D_Var); |
| v_D_initialized := false; |
| log("----D CLEANUP DONE----"); |
| // additional cleanup functions can be called here, but better if you do not call them. Register them instead. |
| } |
| |
| function f_D_Behaviour(in charstring pl_selfName) runs on D_CT { |
| f_D_init_CT(pl_selfName); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| ///////////////////////////////////////////// |
| // stop remote test |
| ///////////////////////////////////////////// |
| |
| // creates two comp-s and exits |
| function f_Comp_A_Behaviour(in charstring pl_selfName) runs on A_CT { |
| f_A_init_CT(pl_selfName); |
| var B_CT v_B_CT := B_CT.create; |
| var C_CT v_C_CT := C_CT.create; |
| v_B_CT.start(f_Comp_B_Behaviour("B",v_C_CT)); |
| v_C_CT.start(f_Comp_C_Behaviour("C")); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| // Kills the C comp and exits |
| function f_Comp_B_Behaviour(in charstring pl_selfName, in C_CT pl_C_CT) runs on B_CT { |
| f_B_init_CT(pl_selfName); |
| // wait a bit before killing C |
| timer t_wait := 1.0; |
| t_wait.start; t_wait.timeout; |
| |
| // stop C |
| f_EPTF_Base_stopRemote(pl_C_CT); |
| |
| // wait a bit before stopping mtc |
| t_wait.start; t_wait.timeout; |
| |
| // stop mtc |
| f_EPTF_Base_stopRemote(mtc); |
| |
| // wait a bit before exiting |
| t_wait.start; t_wait.timeout; |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| // waits for a long time and exits |
| function f_Comp_C_Behaviour(in charstring pl_selfName) runs on C_CT { |
| f_C_init_CT(pl_selfName); |
| // wait a lot before exiting |
| timer t_wait := 10.0; |
| t_wait.start; t_wait.timeout; |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| // exits |
| function f_Comp_D_Behaviour(in charstring pl_selfName) runs on D_CT { |
| f_D_init_CT(pl_selfName); |
| timer t_wait := 5.0; |
| // wait a little before exiting |
| t_wait.start; t_wait.timeout; |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| ///////////////////////////////////////////// |
| // stop all test |
| ///////////////////////////////////////////// |
| |
| // creates two comp-s and exits |
| function f_Comp_A2_Behaviour(in charstring pl_selfName) runs on A_CT { |
| f_A_init_CT(pl_selfName); |
| var B_CT v_B_CT := B_CT.create; |
| var C_CT v_C_CT := C_CT.create; |
| v_B_CT.start(f_Comp_B2_Behaviour("B",v_C_CT)); |
| v_C_CT.start(f_Comp_C2_Behaviour("C")); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| // Kills the C comp and exits |
| function f_Comp_B2_Behaviour(in charstring pl_selfName, in C_CT pl_C_CT) runs on B_CT { |
| f_B_init_CT(pl_selfName); |
| timer t_wait := 1.0; |
| // wait a bit before stopping mtc |
| t_wait.start; t_wait.timeout; |
| |
| // stop all components including the current one |
| f_EPTF_Base_stopAll(pass); |
| } |
| |
| // waits for a long time and exits |
| function f_Comp_C2_Behaviour(in charstring pl_selfName) runs on C_CT { |
| f_C_init_CT(pl_selfName); |
| // wait a lot before exiting |
| timer t_wait := 10.0; |
| t_wait.start; t_wait.timeout; |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| // exits |
| function f_Comp_D2_Behaviour(in charstring pl_selfName) runs on D_CT { |
| f_D_init_CT(pl_selfName); |
| timer t_wait := 10.0; |
| // wait for kill |
| t_wait.start; t_wait.timeout; |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| ///////////////////////////////////////////// |
| // assert test |
| ///////////////////////////////////////////// |
| |
| // calls assert |
| function f_Comp_A3_Behaviour(in charstring pl_selfName) runs on A_CT { |
| f_A_init_CT(pl_selfName); |
| f_EPTF_Base_setNegativeTestMode(); |
| f_EPTF_Base_setExpectedAssertMsg("msg2"); // this message is expected as the first assert |
| f_EPTF_Base_assert("",true); |
| f_EPTF_Base_assert("msg1",true); |
| action("NEGATIVE TEST!!! THE VERDICT OF THIS TESTCASE SHOULD BE PASS!"); |
| f_EPTF_Base_assert("msg2",false); |
| log("This will not be printed"); |
| f_EPTF_Base_assert("msg3",false); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| ///////////////////////////////////////////// |
| // DeadLock |
| ///////////////////////////////////////////// |
| function f_A_deadlock_init_CT(in charstring pl_selfName /* your additional input parameters */) runs on A_DeadLock_CT { |
| if (v_A_initialized) { |
| return; |
| } |
| |
| // call all the init functions of the components that your component extends _explicitly_: |
| f_EPTF_Base_init_CT(pl_selfName /*additional parameters*/); |
| |
| // initialize your component variables here... |
| v_A_Var := 0; |
| |
| v_A_initialized := true; |
| |
| // register your cleanup function: |
| f_EPTF_Base_registerCleanup(refers(f_A_deadlock_cleanup_CT)); |
| |
| log("----A INIT DONE----"); |
| } |
| |
| function f_A_deadlock_cleanup_CT() runs on A_DeadLock_CT { |
| if (v_A_initialized == false) { |
| return; |
| } |
| |
| v_A_initialized := false; |
| hello_PCO.send(1); // this is only sent if this component is stopped |
| log("----A CLEANUP DONE----"); |
| // additional cleanup functions can be called here, but better if you do not call them. Register them instead. |
| } |
| |
| function f_A_deadlock_Behaviour(in charstring pl_selfName) runs on A_DeadLock_CT { |
| f_A_deadlock_init_CT(pl_selfName); |
| timer t_wait := 100.0; |
| t_wait.start; t_wait.timeout; // 'infinite while' |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| function f_C_deadlock_init_CT(in charstring pl_selfName /* your additional input parameters */) runs on C_DeadLock_CT { |
| if (v_C_initialized) { |
| return; |
| } |
| |
| // call all the init functions of the components that your component extends _explicitly_: |
| f_EPTF_Base_init_CT(pl_selfName /*additional parameters*/); |
| |
| // initialize your component variables here... |
| v_A_Var := 0; |
| |
| v_C_initialized := true; |
| |
| // register your cleanup function: |
| f_EPTF_Base_registerCleanup(refers(f_C_deadlock_cleanup_CT)); |
| |
| log("----C INIT DONE----"); |
| } |
| |
| |
| function f_C_deadlock_cleanup_CT() runs on C_DeadLock_CT { |
| if (v_C_initialized == false) { |
| return; |
| } |
| |
| v_C_initialized := false; |
| hello_PCO.receive; // this will wait forever if someone does not kill the A component |
| log("----C CLEANUP DONE----"); |
| // additional cleanup functions can be called here, but better if you do not call them. Register them instead. |
| } |
| |
| ///////////////////////////////////////////// |
| // stopRemote from MTC test |
| ///////////////////////////////////////////// |
| |
| function f_A_StopRemoteFromMTC_init_CT(in charstring pl_selfName /* your additional input parameters */) runs on A_CT { |
| if (v_A_initialized) { |
| return; |
| } |
| |
| // call all the init functions of the components that your component extends _explicitly_: |
| f_EPTF_Base_init_CT(pl_selfName /*additional parameters*/); |
| |
| // initialize your component variables here... |
| v_A_Var := 0; |
| |
| v_A_initialized := true; |
| |
| // register your cleanup function: |
| f_EPTF_Base_registerCleanup(refers(f_A_StopRemoteFromMTC_cleanup_CT)); |
| |
| log("----A INIT DONE----"); |
| } |
| |
| function f_A_StopRemoteFromMTC_cleanup_CT() runs on A_CT { |
| if (v_A_initialized == false) { |
| return; |
| } |
| |
| v_A_initialized := false; |
| log("----A CLEANUP DONE----"); |
| // additional cleanup functions can be called here, but better if you do not call them. Register them instead. |
| } |
| |
| function f_A_StopRemoteFromMTC_Behaviour(in charstring pl_selfName) runs on A_CT { |
| f_A_StopRemoteFromMTC_init_CT(pl_selfName); |
| timer t_wait := 10.0; |
| t_wait.start; t_wait.timeout; // wait for a long time |
| f_EPTF_Base_cleanup_CT(); |
| } |
| ///////////////////////////////////////////// |
| // Regression |
| ///////////////////////////////////////////// |
| function f_Acomp_cleanup_CT() runs on Test_CT { |
| if(v_initialized) { |
| v_initialized := false; |
| setverdict(pass); |
| |
| } else { |
| log("Error: component not initialized"); |
| setverdict(fail); |
| } |
| |
| } |
| |
| function f_Acomp_init_CT() runs on Test_CT { |
| if (not v_initialized) { |
| f_EPTF_Base_init_CT("EPTF_Base_Test_A"); |
| v_initialized := true; |
| f_EPTF_Base_registerCleanup(refers(f_Acomp_cleanup_CT)) |
| setverdict(pass); |
| } else { |
| log("Error: the component allready initialized") |
| setverdict(fail); |
| } |
| } |
| |
| function f_A_behaviour() runs on Test_CT { |
| timer t; |
| f_Acomp_init_CT(); |
| t.start(10.0); |
| t.timeout; |
| log("Error: A component not stopped by MTC"); |
| setverdict(fail); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| function f_cleanup1() runs on Test_CT { |
| if(v_counter1 == 0) { |
| if(v_cleanupOrder == 2) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong cleanup function calling order!"); |
| setverdict(fail); |
| } |
| v_counter1 := v_counter1 + 1; |
| v_cleanupOrder := v_cleanupOrder -1; |
| } |
| if (v_counter1 == 1) { |
| if(v_cleanupOrder == 1) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong cleanup function calling order!"); |
| setverdict(fail); |
| } |
| v_counter1 := v_counter1 + 1; |
| v_cleanupOrder := v_cleanupOrder -1; |
| } |
| } |
| |
| function f_cleanup2() runs on Test_CT { |
| if(v_cleanupOrder == 3) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong cleanup function calling order!"); |
| setverdict(fail); |
| } |
| v_cleanupOrder := v_cleanupOrder - 1; |
| f_cleanup1(); |
| v_counter2 := v_counter2 + 1; |
| } |
| |
| ///////////////////////////////////////////// |
| // needed for tc_EPTF_Base_Test_executeShel |
| /////////////////////////////////////////////l |
| altstep as_EPTF_Base_Test_timeout() runs on Test_CT { |
| [] t_wait1.timeout{ |
| v_counter1 := v_counter1+1; |
| } |
| } |
| |
| } //end of module |