| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // Copyright (c) 2000-2017 Ericsson Telecom AB // |
| // // |
| // All rights reserved. This program and the accompanying materials // |
| // are made available under the terms of the Eclipse Public License v1.0 // |
| // which accompanies this distribution, and is available at // |
| // http://www.eclipse.org/legal/epl-v10.html // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////// |
| // Module: EPTF_LGenBase_Test_TestcasesR4 |
| // |
| // Purpose: |
| // This module provides functions for testing new R4 functionalities of LGenBase |
| // |
| // Module depends on: |
| // - |
| // |
| // Current Owner: |
| // László Skumát (ELSZSKU) |
| // |
| // Last Review Date: |
| // - |
| // |
| /////////////////////////////////////////////////////////////// |
| module EPTF_LGenBase_Test_TestcasesR4 |
| { |
| import from EPTF_LGenBase_Test_Functions all; |
| import from EPTF_LGenBase_Test_TestcasesR3 all; |
| import from EPTF_CLL_StatMeasure_Functions all; |
| import from EPTF_CLL_LGenBase_ConfigDefinitions all; |
| import from EPTF_CLL_LGenBase_EventHandlingFunctions all; |
| import from EPTF_LGenBase_Test_Definitions all; |
| //import from EPTF_LGenBase_Test_Functions all; |
| import from EPTF_CLL_Common_Definitions all; |
| //import from EPTF_CLL_Base_Definitions all; |
| import from EPTF_CLL_LGenBase_Definitions all; |
| import from EPTF_CLL_LGenBase_Functions all; |
| import from EPTF_CLL_LGenBaseStats_Definitions all; |
| //import from EPTF_CLL_LGenBaseStats_Functions all; |
| //import from EPTF_CLL_LGenBase_ConfigDefinitions all; |
| import from EPTF_CLL_LGenBase_ConfigFunctions all; |
| import from EPTF_CLL_LGenBase_TrafficFunctions all; |
| //import from EPTF_CLL_LGenBase_StepFunctions all; |
| //import from EPTF_CLL_LGenBase_EventHandlingFunctions all; |
| //import from EPTF_CLL_LGenBase_LoggingFunctions all; |
| import from EPTF_CLL_Logging_Functions all; |
| //import from EPTF_CLL_FBQ_Functions all; |
| import from EPTF_CLL_Base_Functions all; |
| import from EPTF_CLL_Variable_Functions all; |
| import from EPTF_CLL_Variable_Definitions all; |
| //import from EPTF_CLL_StatHandlerClient_Definitions all; |
| //import from EPTF_CLL_StatMeasure_Definitions all |
| //import from EPTF_CLL_StatMeasure_Functions all |
| //import from EPTF_CLL_RBTScheduler_Functions all; |
| //import from EPTF_CLL_StatHandlerClient_Functions all; |
| //import from EPTF_CLL_Scheduler_Definitions all |
| import from PIPEasp_PortType all |
| import from PIPEasp_Types all |
| import from TCCConversion_Functions all |
| |
| group lastCPS{ |
| testcase tc_lastCPSIs0() |
| runs on EPTF_LGenBase_CT{ |
| const charstring c_eGrpName := "eg0" |
| const charstring c_scName := "Scenario_Simple" |
| const charstring c_scNameWeighted :="Scenario_Weighted" |
| const charstring c_tcName := "testTC" |
| f_EPTF_LGenBase_init("") |
| var integer |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "statFSM", |
| fsmParams := { |
| {stateList := {"idle"}} |
| ,{varList := { |
| {name := "vf_callCounter", initValue := {intVal := 0}, scope := TC} |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := { bName := "EPTF_CLL_LGenBase", iName := "LGenBase: Start_the_traffic_case!", eventType := fsm }, |
| cellRow := { |
| //state==idle |
| {actionList := { |
| {stepOrFunctionName := c_EPTF_LGenBase_stepName_trafficSuccess, contextArgs := omit} |
| ,{stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarInc, contextArgs :={varParams := {"vf_callCounter",{intVal := 1}}}} |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm //XCAPget_DOT:} |
| ) |
| v_dummyInt := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg_base", eType := "Entity_Tc_A", eCount := 125}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg_base2", eType := "Entity_Tc_A", eCount := 57}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := c_eGrpName, eType := "Entity_Tc_A", eCount := 5}) |
| v_dummyInt := f_EPTF_LGenBase_declareTcType2({ |
| name := "statTC", |
| fsmName := "statFSM", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := c_scName, |
| tcList := { |
| { tcName := "statTC0", |
| tcParamsList := { |
| {tcTypeName := "statTC"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := false}, |
| {target := {cpsToReach := 1111.0}} |
| } |
| }, |
| { tcName := c_tcName, |
| tcParamsList := { |
| {tcTypeName := "statTC"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {cpsToReach := 1111.0}} |
| } |
| } |
| }, |
| scParamsList := { |
| {enabled := true} |
| } |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := c_scNameWeighted, |
| tcList := { |
| { tcName := "statTC0", |
| tcParamsList := { |
| {tcTypeName := "statTC"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {trafficWeight := 0.5}} |
| } |
| }, |
| { tcName := c_tcName, |
| tcParamsList := { |
| {tcTypeName := "statTC"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {trafficWeight := 0.5}} |
| } |
| } |
| }, |
| scParamsList := { |
| {weightedScData := { |
| cpsToReach := 1111.0, |
| lockCPS := false, |
| deterministicMix := false, |
| scheduler := omit |
| } |
| }, |
| {enabled := true} |
| } |
| }) |
| |
| //Simple scenario |
| f_EPTF_LGenBase_createScenario2EntityGroup({c_eGrpName, c_scName},true) |
| timer t_wait |
| t_wait.start( 3.4 ) |
| t_wait.timeout |
| var float vl_cps := f_EPTF_LGenBase_getCPSByNames(c_eGrpName, c_scName, c_tcName) |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log(%definitionId,vl_cps) |
| } |
| if(0.0 == vl_cps){ |
| setverdict ( fail,"The CPS is 0.0"); |
| } |
| vl_cps := f_EPTF_LGenBase_getMeasuredCPSByNames(c_eGrpName, c_scName, c_tcName) |
| if(0.0 == vl_cps){ |
| setverdict ( fail, "The measured CPS is 0.0" ); |
| } |
| var charstring vl_pre := f_EPTF_LGenBase_getNamePrefix(c_eGrpName, c_scName, c_tcName) |
| vl_pre := vl_pre & c_EPTF_LGenBaseStats_nameOfTcCpsToReach |
| var integer vl_varId := f_EPTF_Var_getId(vl_pre) |
| var EPTF_Var_DirectContent vl_content |
| vl_content.floatVal := 0.0 |
| f_EPTF_Var_adjustContent(vl_varId, vl_content) |
| //f_EPTF_LGenBase_setCPSByNames(c_eGrpName, c_scName, c_tcName, 0.0) |
| vl_cps := f_EPTF_LGenBase_getTcCpsToReachByName(c_eGrpName, c_scName, c_tcName) |
| if(0.0 != vl_cps){ |
| setverdict ( fail, "The target CPS is ",vl_cps," instead of 0.0" ); |
| } |
| t_wait.start( 2.2 ) |
| t_wait.timeout |
| vl_cps := f_EPTF_LGenBase_getCPSByNames(c_eGrpName, c_scName, c_tcName) |
| if(0.0 == vl_cps){ |
| setverdict ( fail, "The CPS is 0.0. It should be the las non-0 value" ); |
| } |
| var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(c_eGrpName, c_scName, c_tcName) |
| vl_cps := f_EPTF_LGenBase_getMeasuredCPSByIdx(vl_tcIdx) |
| if(0.0 != vl_cps){ |
| setverdict ( fail, "The measured CPS is",vl_cps," instead of 0.0" ); |
| } |
| var integer vl_scIdx := f_EPTF_LGenBase_scenarioAbsIdxByName(c_eGrpName, c_scName) |
| var integer vl_eGrpIdx, vl_scRelIdx |
| f_EPTF_LGenBase_scenarioRelIdx(vl_scIdx, vl_eGrpIdx, vl_scRelIdx) |
| f_EPTF_LGenBase_stopScenarioByIdx(vl_eGrpIdx, vl_scRelIdx) |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log(%definitionId,vl_cps) |
| } |
| //Weighted scenario |
| f_EPTF_LGenBase_createScenario2EntityGroup({c_eGrpName, c_scNameWeighted},true) |
| t_wait.start( 3.4 ) |
| t_wait.timeout |
| var charstring vl_varName := f_EPTF_LGenBase_varNameOfTCVar( |
| f_EPTF_LGenBase_trafficCaseId(c_eGrpName, c_scNameWeighted, c_tcName), |
| "vf_callCounter") |
| var integer vl_tcVarIdx := f_EPTF_Var_getId(vl_varName) |
| f_EPTF_Var_getContent(vl_tcVarIdx, vl_content) |
| if(0 == vl_content.intVal){ |
| setverdict ( fail ); |
| } |
| f_EPTF_LGenBase_setScenarioCPS(c_eGrpName, c_scNameWeighted, 0.0) |
| vl_content.intVal := 0 |
| f_EPTF_Var_adjustContent(vl_tcVarIdx, vl_content) |
| t_wait.start( 1.2 ) |
| t_wait.timeout |
| f_EPTF_Var_getContent(vl_tcVarIdx, vl_content) |
| if(0 != vl_content.intVal){ |
| setverdict ( fail, "The counter is ",vl_content.intVal," instead of 0" ) |
| }else{ |
| setverdict( pass) |
| } |
| f_EPTF_Base_cleanup_CT() |
| } |
| } |
| |
| testcase tc_dispatcEntityEvent() |
| runs on EPTF_LGenBase_CT{ |
| f_EPTF_LGenBase_init("") |
| var integer |
| v_bIdx := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| var integer |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i1") |
| var integer |
| v_iIdx := f_EPTF_LGenBase_declareFsmEvent("b1", "i2") |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg_base", eType := "Entity_Tc_A", eCount := 125}) |
| var integer |
| v_FSM := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "statFSM", |
| fsmParams := { |
| {stateList := {"idle"}} |
| ,{varList := { |
| {name := "vf_callCounter", initValue := {intVal := 0}, scope := FSM} |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := { bName := "b1", iName := "i1", eventType := entity }, |
| cellRow := { |
| //state==idle |
| {actionList := { |
| {stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarInc, contextArgs :={varParams := {"vf_callCounter",{intVal := 1}}}} |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| ,{eventToListen := { bName := "b1", iName := "i2", eventType := entity }, |
| cellRow := { |
| //state==idle |
| {actionList := { |
| {stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarInc, contextArgs :={varParams := {"vf_callCounter",{intVal := 1}}}} |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm //XCAPget_DOT:} |
| ) |
| v_dummyInt := f_EPTF_LGenBase_activateFsm(1, v_FSM, 0, -1) |
| //Out of range of v_LGenBase_entities |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {1000, omit}, omit},{}}); |
| //Out of range of v_LGenBase_entities |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {348, omit}, omit},{}}); |
| //Entity with activated FSM |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {1, omit}, omit},{}}); |
| //Entity with inactive FSM |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {60, omit}, omit},{}}); |
| //Out of range of v_LGenBase_entities |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {260, omit}, omit},{}}); |
| var charstring vl_varName := f_EPTF_LGenBase_varNameOfFSMVar(1, 0, "vf_callCounter") |
| var integer vl_tcVarIdx := f_EPTF_Var_getId(vl_varName) |
| var EPTF_Var_DirectContent vl_content |
| f_EPTF_Var_getContent(vl_tcVarIdx, vl_content) |
| if(1 != vl_content.intVal){ |
| log(vl_content) |
| setverdict ( fail ); |
| }else{ |
| setverdict(pass) |
| } |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| testcase tc_dispatcEntityEvent4TC() |
| runs on EPTF_LGenBase_CT{ |
| f_EPTF_LGenBase_init("") |
| var integer |
| v_bIdx := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| var integer |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i1") |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i3") |
| var integer |
| v_iIdx := f_EPTF_LGenBase_declareFsmEvent("b1", "i2") |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 25}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg1", eType := "Entity_Tc_A", eCount := 125}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg2", eType := "Entity_Tc_A", eCount := 200}) |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "statFSM", |
| fsmParams := { |
| {stateList := {"idle"}} |
| ,{varList := { |
| {name := "vf_callCounter", initValue := {intVal := 0}, scope := TC} |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := { bName := "b1", iName := "i1", eventType := entity }, |
| cellRow := { |
| //state==idle |
| {actionList := { |
| {stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarInc, contextArgs :={varParams := {"vf_callCounter",{intVal := 1}}}} |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| ,{eventToListen := { bName := "b1", iName := "i2", eventType := entity }, |
| cellRow := { |
| //state==idle |
| {actionList := { |
| {stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarInc, contextArgs :={varParams := {"vf_callCounter",{intVal := 1}}}} |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm //XCAPget_DOT:} |
| ) |
| v_dummyInt := f_EPTF_LGenBase_declareTcType2({ |
| name := "statTC", |
| fsmName := "statFSM", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := "sc1", |
| tcList := { |
| { tcName := "statTC0", |
| tcParamsList := { |
| {tcTypeName := "statTC"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := false}, |
| {target := {cpsToReach := 1111.0}} |
| } |
| }, |
| { tcName := "tc1", |
| tcParamsList := { |
| {tcTypeName := "statTC"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {cpsToReach := 1111.0}} |
| } |
| } |
| }, |
| scParamsList := { |
| {enabled := true} |
| } |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg1","sc1"}, false) |
| //Out of range of v_LGenBase_entities |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {1000, omit}, omit},{}}); |
| //Entity in the 3rd entity group, rel idx> sizeof(entityGroup[1]) |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {348, omit}, omit},{}}); |
| //Entity in the 1st entity group |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {1, omit}, omit},{}}); |
| //Entity in the tc |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {60, omit}, omit},{}}); |
| //Entity in the 3rd entity group, rel idx< sizeof(entityGroup[1]) |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {260, omit}, omit},{}}); |
| var charstring vl_varName := f_EPTF_LGenBase_varNameOfTCVar(1, "vf_callCounter") |
| var integer vl_tcVarIdx := f_EPTF_Var_getId(vl_varName) |
| var EPTF_Var_DirectContent vl_content |
| f_EPTF_Var_getContent(vl_tcVarIdx, vl_content) |
| if(1 != vl_content.intVal){ |
| action(vl_content) |
| log(vl_content) |
| setverdict ( fail ); |
| }else{ |
| setverdict(pass) |
| } |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| group fsms{ |
| template EPTF_LGenBase_InternalFsmTable t_EPTF_LGenBaseTest_fsmCompare( |
| in charstring pl_name, |
| in EPTF_LGenBase_InternalFsmTable pl_table2Compare |
| ) := { |
| name := pl_name, |
| stateList := pl_table2Compare.stateList, |
| timerList := pl_table2Compare.timerList, |
| varListArray := pl_table2Compare.varListArray, |
| statisticListArray := pl_table2Compare.statisticListArray, |
| statMeasStatListArray := pl_table2Compare.statMeasStatListArray, |
| eventXref := pl_table2Compare.eventXref, |
| rows := pl_table2Compare.rows, |
| varCounts := pl_table2Compare.varCounts, |
| statisticCounts := pl_table2Compare.statisticCounts, |
| statMeasCounts := pl_table2Compare.statMeasCounts, |
| varNamesHash := ?, |
| stateNamesHash := ?, |
| statisticNamesHash := ?, |
| statMeasNamesHash := ?, |
| timerNamesHash := ?, |
| |
| varXRefs := pl_table2Compare.varXRefs, |
| statisticXRefs := pl_table2Compare.statisticXRefs, |
| statMeasXRefs := pl_table2Compare.statMeasXRefs, |
| paramValues := pl_table2Compare.paramValues, |
| |
| catchAllRowIdxList := pl_table2Compare.catchAllRowIdxList, |
| unhandledEventRowIdxList := pl_table2Compare.unhandledEventRowIdxList, |
| debugLight := ?, |
| referredFsmList := ?, |
| siblingListenerRowList := ?, |
| referredTCList := ? |
| } |
| |
| testcase tc_compareFSMs() |
| runs on EPTF_LGenBase_CT{ |
| const charstring c_fsmName := "CompareFSMs_paramed" |
| var EPTF_LGenBase_CompactFsmTableDeclarator vl_table := { |
| name := c_fsmName, |
| stateList := {"idle", "busy"}, |
| timerList := {{"timer",1.3}}, |
| table := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{{c_EPTF_LGenBase_stepName_timerStart, {timerName := "timer"}}}, omit, "busy"}, |
| {omit, omit, omit} |
| } |
| }, |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_stopTC,fsm}, |
| cellRow := { |
| {{{c_EPTF_LGenBase_stepName_entityStopped, omit}}, omit, omit}, |
| {{ |
| {c_EPTF_LGenBase_stepName_timerCancel, {timerName := "timer"}}, |
| {c_EPTF_LGenBase_stepName_entityStopped, omit}, |
| {c_EPTF_LGenBase_stepName_trafficSuccess, omit} |
| }, omit, "idle"} |
| } |
| }, |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_abortTC,fsm}, |
| cellRow := { |
| {{{c_EPTF_LGenBase_stepName_entityAborted, omit}}, omit, omit}, |
| {{ |
| {c_EPTF_LGenBase_stepName_timerCancel, {timerName := "timer"}}, |
| {c_EPTF_LGenBase_stepName_entityAborted, omit}, |
| {c_EPTF_LGenBase_stepName_trafficSuccess, omit} |
| }, omit, "idle"} |
| } |
| }, |
| {eventToListen := {c_EPTF_LGenBase_specialBName_timerTimeout,"timer",fsm}, |
| cellRow := { |
| {omit, omit, omit}, |
| {{{c_EPTF_LGenBase_stepName_trafficSuccess, omit}}, omit, "idle"} |
| } |
| } |
| } |
| } |
| var EPTF_LGenBase_FsmTableDeclarator vl_flexFsm1 := { |
| name := c_fsmName, |
| fsmParams := |
| { |
| {stateList := {"idle", "busy"}}, |
| {timerList := {{"timer",1.3}} |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{{c_EPTF_LGenBase_stepName_timerStart, {timerName := "timer"}}}, omit, "busy"}, |
| {omit, omit, omit} |
| } |
| }, |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_stopTC,fsm}, |
| cellRow := { |
| {{{c_EPTF_LGenBase_stepName_entityStopped, omit}}, omit, omit}, |
| {{ |
| {c_EPTF_LGenBase_stepName_timerCancel, {timerName := "timer"}}, |
| {c_EPTF_LGenBase_stepName_entityStopped, omit}, |
| {c_EPTF_LGenBase_stepName_trafficSuccess, omit} |
| }, omit, "idle"} |
| } |
| }, |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_abortTC,fsm}, |
| cellRow := { |
| {{{c_EPTF_LGenBase_stepName_entityAborted, omit}}, omit, omit}, |
| {{ |
| {c_EPTF_LGenBase_stepName_timerCancel, {timerName := "timer"}}, |
| {c_EPTF_LGenBase_stepName_entityAborted, omit}, |
| {c_EPTF_LGenBase_stepName_trafficSuccess, omit} |
| }, omit, "idle"} |
| } |
| }, |
| {eventToListen := {c_EPTF_LGenBase_specialBName_timerTimeout,"timer",fsm}, |
| cellRow := { |
| {omit, omit, omit}, |
| {{{c_EPTF_LGenBase_stepName_trafficSuccess, omit}}, omit, "idle"} |
| } |
| } |
| } |
| } |
| } |
| |
| var EPTF_LGenBase_FsmTableDeclarator vl_flexFsm2 := { |
| name := "FlexFsm2", |
| fsmParams := |
| { |
| {stateList := {"idle", "busy"}}, |
| {timerList := {{"timer",1.3}} |
| } |
| }, |
| table := { |
| extendedTable := { |
| { |
| events2Listen := {events := { {singleEvent := { |
| c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm |
| }}}}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "idle"}, |
| cell := {{{c_EPTF_LGenBase_stepName_timerStart, {timerName := "timer"}}}, omit, "busy"} |
| }, |
| { |
| inState := {state := "busy"}, |
| cell := {omit, omit, omit} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { {singleEvent := { |
| c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_stopTC,fsm} |
| }}}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "idle"}, |
| cell := {{{c_EPTF_LGenBase_stepName_entityStopped, omit}}, omit, omit} |
| }, |
| { |
| inState := {state := "busy"}, |
| cell := {{ |
| {c_EPTF_LGenBase_stepName_timerCancel, {timerName := "timer"}}, |
| {c_EPTF_LGenBase_stepName_entityStopped, omit}, |
| {c_EPTF_LGenBase_stepName_trafficSuccess, omit}} |
| , omit, "idle"} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { {singleEvent := { |
| c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_abortTC,fsm} |
| }}}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "idle"}, |
| cell := {{ |
| {c_EPTF_LGenBase_stepName_entityAborted, omit}}, omit, omit} |
| }, |
| { |
| inState := {state := "busy"}, |
| cell := {{ |
| {c_EPTF_LGenBase_stepName_timerCancel, {timerName := "timer"}}, |
| {c_EPTF_LGenBase_stepName_entityAborted, omit}, |
| {c_EPTF_LGenBase_stepName_trafficSuccess, omit} |
| }, omit, "idle"} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { {singleEvent := { |
| c_EPTF_LGenBase_specialBName_timerTimeout,"timer",fsm} |
| }}}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "idle"}, |
| cell := {omit, omit, omit} |
| }, |
| { |
| inState := {state := "busy"}, |
| cell := {{ |
| {c_EPTF_LGenBase_stepName_trafficSuccess, omit}}, omit, "idle"} |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| f_EPTF_LGenBase_init("compareFSMs") |
| var integer vl_fsmOrig := f_EPTF_LGenBase_declareParamedFsmTable(vl_table) |
| vl_flexFsm1.name := c_fsmName&"2" |
| var integer vl_fsmNew := f_EPTF_LGenBase_declareFSMTable(vl_flexFsm1) |
| if(match(f_EPTF_LGenBase_getFSMTable(vl_fsmOrig),t_EPTF_LGenBaseTest_fsmCompare(c_fsmName, f_EPTF_LGenBase_getFSMTable(vl_fsmNew)))){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail) |
| log(match(f_EPTF_LGenBase_getFSMTable(vl_fsmOrig),t_EPTF_LGenBaseTest_fsmCompare(c_fsmName, f_EPTF_LGenBase_getFSMTable(vl_fsmNew)))) |
| } |
| vl_flexFsm1.name := c_fsmName&"3" |
| vl_fsmNew := f_EPTF_LGenBase_declareFSMTable(vl_flexFsm2) |
| if(match(f_EPTF_LGenBase_getFSMTable(vl_fsmOrig),t_EPTF_LGenBaseTest_fsmCompare(c_fsmName, f_EPTF_LGenBase_getFSMTable(vl_fsmNew)))){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail) |
| log(match(f_EPTF_LGenBase_getFSMTable(vl_fsmOrig),t_EPTF_LGenBaseTest_fsmCompare(c_fsmName, f_EPTF_LGenBase_getFSMTable(vl_fsmNew)))) |
| } |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| const EPTF_IntegerList c_dummyArgs := {5,7,4,8} |
| |
| function f_EPTF_LGenBase_testFSMs_checkAddThreeInAnyStateMoveIdle( |
| in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on testFSMs_CT |
| { |
| var EPTF_LGenBase_ReportedEventDescriptor vl_evetExpected := c_EPTF_LGenBase_emptyReportedEventDescriptor |
| vl_evetExpected.event.bIdx := v_testFSMs_behav |
| vl_evetExpected.event.iIdx := v_addThreeInAnyStateMoveIdle |
| vl_evetExpected.event.target.eIdx := pl_ptr.eIdx |
| vl_evetExpected.event.target.fsmCtxIdx := pl_ptr.refContext.fCtxIdx |
| vl_evetExpected.event.source := omit |
| vl_evetExpected.reportedArgs := c_dummyArgs |
| if(not match(pl_ptr.reportedEvent, vl_evetExpected)){ |
| setverdict(fail, log2str(match(pl_ptr.reportedEvent, vl_evetExpected))) |
| } |
| } |
| |
| type component testFSMs_CT extends EPTF_LGenBase_CT{ |
| var integer v_testFSMs_behav |
| var integer v_addTwoInBusy |
| var integer v_noListen |
| var integer v_addTwo2 |
| var integer v_addTwo3 |
| var integer v_addTwoOverlapped |
| var integer v_addTwoInBusyNineInIdle |
| var integer v_addThreeInAnyStateMoveIdle |
| var integer v_moveToThird |
| var integer v_moveToBusy |
| var integer v_addSevenInAnyFiveInBusy |
| var integer v_twoRowsAddSevenInThird |
| } |
| testcase tc_testFSMs() |
| runs on testFSMs_CT{ |
| f_EPTF_LGenBase_init("testFSMs") |
| v_testFSMs_behav := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| v_addTwoInBusy := f_EPTF_LGenBase_declareFsmEvent("b1","addTwoInBusy"); |
| v_noListen := f_EPTF_LGenBase_declareFsmEvent("b1","noListen"); |
| v_addTwo2 := f_EPTF_LGenBase_declareFsmEvent("b1","addTwo2"); |
| v_addTwo3 := f_EPTF_LGenBase_declareFsmEvent("b1","addTwo3"); |
| v_addTwoOverlapped := f_EPTF_LGenBase_declareFsmEvent("b1","addTwoOverlapped"); |
| v_addTwoInBusyNineInIdle := f_EPTF_LGenBase_declareFsmEvent("b1","addTwoInBusyNineInIdle"); |
| v_addThreeInAnyStateMoveIdle := f_EPTF_LGenBase_declareFsmEvent("b1","addThreeInAnyStateMoveIdle"); |
| v_moveToThird := f_EPTF_LGenBase_declareFsmEvent("b1","moveToThird"); |
| v_moveToBusy := f_EPTF_LGenBase_declareFsmEvent("b1","moveToBusy"); |
| v_addSevenInAnyFiveInBusy := f_EPTF_LGenBase_declareFsmEvent("b1","addSevenInAnyFiveInBusy"); |
| v_twoRowsAddSevenInThird := f_EPTF_LGenBase_declareFsmEvent("b1","twoRowsAddSevenInThird"); |
| var integer |
| v_dummyInt := f_EPTF_LGenBase_declareStep("b1", {"checkAddThreeInAnyStateMoveIdle",refers(f_EPTF_LGenBase_testFSMs_checkAddThreeInAnyStateMoveIdle)}) |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("et1", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({"eg1", "et1", 1}) |
| var EPTF_LGenBase_FsmTableDeclarator vl_flexFsm1 := { |
| name := "FlexFsm1", |
| fsmParams := |
| { |
| {varList := { |
| { |
| name := "var1", |
| initValue := {intVal := 0}, |
| scope := FSM |
| } |
| }}, |
| {stateList := {"idle", "busy","third"}}, |
| {timerList := {{"timer",1.3}} |
| } |
| }, |
| table := { |
| extendedTable := { |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","moveToBusy", fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {anyUndefinedState := {} }, |
| cell := { |
| omit, omit, "busy"} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := { |
| events := { |
| { singleEvent := {"b1","addTwoInBusy", fsm} }, |
| { eventRange := {"b1","addTwo2", "addTwoInBusyNineInIdle", fsm} }, // event range |
| { eventRange := {"b1","addTwo3", "addTwoOverlapped", fsm} }, // overlapped range |
| { eventList := {"b1", { "addTwo3", "addTwoOverlapped", "addTwoInBusyNineInIdle" }, fsm} }, // event list |
| { eventList := {"b1", {}, fsm} } // empty list |
| } |
| }, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "busy"}, |
| cell := { |
| {{"LGenBase: Increment variable",{varParams := {"var1",{intVal := 2}}}}}, omit, omit} |
| } |
| } // classicCellRow |
| } // cellRow |
| }, |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","addTwoInBusyNineInIdle", fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "idle"}, |
| cell := { |
| {{"LGenBase: Increment variable",{varParams := {"var1",{intVal := 9}}}}} |
| , omit, omit} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","twoRowsAddSevenInThird", fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "third"}, |
| cell := { |
| {{"LGenBase: Increment variable",{varParams := {"var1",{intVal := 3}}}}} |
| , omit, omit} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","twoRowsAddSevenInThird", fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "third"}, |
| cell := { |
| {{"LGenBase: Increment variable",{varParams := {"var1",{intVal := 4}}}}} |
| , omit, omit} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","addThreeInAnyStateMoveIdle", fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {anyUndefinedState := {} }, |
| cell := { |
| { |
| {"LGenBase: Increment variable",{varParams := {"var1",{intVal := 3}}}}, |
| {"checkAddThreeInAnyStateMoveIdle",omit} |
| } |
| , omit, "idle"} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","moveToThird", fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {stateList := {"busy","idle"}}, |
| cell := { |
| omit |
| , omit, "third"} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","addSevenInAnyFiveInBusy", fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "busy"}, |
| cell := { |
| {{"LGenBase: Increment variable",{varParams := {"var1",{intVal := 5}}}}} |
| , omit, omit} |
| }, |
| { |
| inState := {anyUndefinedState := {} }, |
| cell := { |
| {{"LGenBase: Increment variable",{varParams := {"var1",{intVal := 7}}}}} |
| , omit, omit} |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| //twoRowsAddSevenInThird |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable(vl_flexFsm1) |
| v_dummyInt := f_EPTF_LGenBase_declareTcType2({ |
| "TC1", |
| "FlexFsm1", |
| "et1", |
| "" |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { "SC1", |
| { |
| {"TC1",{{target := {cpsToReach := 0.0}}}} |
| }, |
| {} |
| }) |
| var integer vl_expected := 0 |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg1","SC1"},false) |
| var EPTF_Var_DirectContent vl_content; |
| var integer vl_var1 := f_EPTF_Var_getId(f_EPTF_LGenBase_varNameOfFSMVar(0,0,"var1")) |
| if(vl_var1 < 0){ |
| setverdict(fail,"The variable can't be reached.") |
| } |
| f_checkContent(vl_var1,vl_expected) |
| //-------sate idle |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log("Check no listener") |
| } |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_noListen, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log("Check anyState when there is no defined state") |
| } |
| vl_expected := vl_expected +7 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addSevenInAnyFiveInBusy, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log("Check different listeners in idle state") |
| } |
| vl_expected := vl_expected +9 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addTwoInBusyNineInIdle, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| // |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log("Check anyState in idle") |
| } |
| vl_expected := vl_expected +3 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addThreeInAnyStateMoveIdle, {0,0}, omit}, c_dummyArgs }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log("Check no action in the state") |
| } |
| //vl_expected := vl_expected +0 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addTwoOverlapped, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| // |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log("Check anyState when there is a defined state") |
| } |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_moveToBusy, {0,0}, omit}, {} }); |
| //-------sate busy |
| vl_expected := vl_expected +5 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addSevenInAnyFiveInBusy, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| vl_expected := vl_expected +2 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addTwoOverlapped, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log("Check different listeners in busy state") |
| } |
| vl_expected := vl_expected +2 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addTwoInBusyNineInIdle, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log("Check anyState in busy") |
| } |
| vl_expected := vl_expected +3 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addThreeInAnyStateMoveIdle, {0,0}, omit}, c_dummyArgs }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_moveToThird, {0,0}, omit}, {} }); |
| //-------sate third |
| |
| vl_expected := vl_expected +7 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addSevenInAnyFiveInBusy, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| //vl_expected := vl_expected +0 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addTwoOverlapped, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| //vl_expected := vl_expected +0 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addTwoInBusyNineInIdle, {0,0}, omit}, {} }); |
| f_checkContent(vl_var1,vl_expected) |
| |
| vl_expected := vl_expected +3 |
| f_EPTF_LGenBase_dispatchEvent({ { v_testFSMs_behav, v_addThreeInAnyStateMoveIdle, {0,0}, omit}, c_dummyArgs }); |
| f_checkContent(vl_var1,vl_expected) |
| setverdict(pass) |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| function f_checkContent(in integer pl_varId, in integer pl_expected) |
| runs on EPTF_Var_CT{ |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getContent(pl_varId, vl_content); |
| if(not match(vl_content, {intVal := pl_expected})){ |
| setverdict(fail,"The content of the variable should be "&int2str(pl_expected)&" instead of ",vl_content) |
| } |
| } |
| } |
| |
| testcase tc_fsmDeclCompare() runs on EPTF_LGenBase_CT{ |
| const charstring c_fsmName := "fsmDeclCompare" |
| var EPTF_LGenBase_FsmTableDeclarator vl_decl1 := { |
| name := c_fsmName, |
| fsmParams := { |
| { |
| stateList := { |
| "idle", |
| "initiated", |
| "retryAfter" |
| } |
| }, |
| { |
| timerList := { |
| { |
| name := "T_userWatchdog", |
| startValue := 40.000000 |
| }, |
| { |
| name := "T_retryAfter", |
| startValue := 5.000000 |
| } |
| } |
| }, |
| { |
| varList := { |
| { |
| name := "vi_retryAfter", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := FSM |
| } |
| } |
| }, |
| { |
| statHandlerStatList := { |
| { |
| name := "Retry-Afters", |
| providers := { |
| { |
| varList := { |
| "vi_retryAfter" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| } |
| } |
| }, |
| { |
| varList := { |
| { |
| name := "vi_reqSent", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_reqSendError", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_reqRecvOk", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_reqRecvNOk", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_respRecvOk", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_respRecvNOk", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_timeOut", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vf_rtt", |
| initValue := { |
| floatVal := 0.000000 |
| }, |
| scope := TC |
| } |
| } |
| }, |
| { |
| statMeasWithParamsList := { |
| { |
| name := "l_latency", |
| providerVarName := "", |
| targetVarName := "vf_rtt", |
| statMeasParams := { |
| statType := chrono |
| }, |
| scope := FSM |
| } |
| } |
| }, |
| { |
| statHandlerStatList := { |
| { |
| name := "ReqSent", |
| providers := { |
| { |
| varList := { |
| "vi_reqSent" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "ReqSentInError", |
| providers := { |
| { |
| varList := { |
| "vi_reqSendError" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "RequestsReceivedOk", |
| providers := { |
| { |
| varList := { |
| "vi_reqRecvOk" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| } |
| } |
| }, |
| { |
| statMeasWithParamsList := { |
| { |
| name := "l_m_rtt", |
| providerVarName := "vf_rtt", |
| targetVarName := "", |
| statMeasParams := { |
| params := { |
| percentileP := { |
| valueP := 0.500000, |
| density := { |
| scale := { |
| min := 0.010000, |
| max := 5.000000, |
| n := 20, |
| scale := logarithmic |
| } |
| } |
| } |
| } |
| }, |
| scope := TC |
| }, |
| { |
| name := "l_p95_rtt", |
| providerVarName := "vf_rtt", |
| targetVarName := "", |
| statMeasParams := { |
| params := { |
| percentile95 := { |
| scale := { |
| min := 0.010000, |
| max := 5.000000, |
| n := 20, |
| scale := logarithmic |
| } |
| } |
| } |
| }, |
| scope := TC |
| }, |
| { |
| name := "l_d_rtt", |
| providerVarName := "vf_rtt", |
| targetVarName := "", |
| statMeasParams := { |
| params := { |
| density := { |
| scale := { |
| min := 0.010000, |
| max := 5.000000, |
| n := 20, |
| scale := logarithmic |
| } |
| } |
| } |
| }, |
| scope := TC |
| } |
| } |
| }, |
| { |
| statHandlerStatList := { |
| { |
| name := "RequestsReceivedNOk", |
| providers := { |
| { |
| varList := { |
| "vi_reqRecvNOk" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "ResponsesReceivedOk", |
| providers := { |
| { |
| varList := { |
| "vi_respRecvOk" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "ResponsesReceivedNOk", |
| providers := { |
| { |
| varList := { |
| "vi_respRecvNOk" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "timeOuts", |
| providers := { |
| { |
| varList := { |
| "vi_timeOut" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "latency_percentile95", |
| providers := { |
| { |
| statMeas := "l_p95_rtt" |
| } |
| }, |
| statMethod := "Percentile95", |
| statResetValue := { |
| floatVal := 0.000000 |
| }, |
| scope := TC |
| }, |
| { |
| name := "latency_median", |
| providers := { |
| { |
| statMeas := "l_m_rtt" |
| } |
| }, |
| statMethod := "PercentileP", |
| statResetValue := { |
| floatVal := 0.000000 |
| }, |
| scope := TC |
| }, |
| { |
| name := "latency", |
| providers := { |
| { |
| statMeas := "l_d_rtt" |
| } |
| }, |
| statMethod := "Density", |
| statResetValue := { |
| integerlistVal := { |
| 0,0,0,0,0, |
| 0,0,0,0,0, |
| 0,0,0,0,0, |
| 0,0,0,0,0, |
| 0 |
| } |
| }, |
| scope := TC |
| } |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| { |
| eventToListen := { |
| bName := "EPTF_CLL_LGenBase", |
| iName := "LGenBase: Start_the_traffic_case!", |
| eventType := fsm |
| }, |
| cellRow := { |
| { |
| actionList := { |
| { |
| stepOrFunctionName := c_EPTF_LGenBase_stepName_recordEntityStart, |
| contextArgs := omit |
| }, |
| { |
| stepOrFunctionName := "LGenBase: StepFunction_timerStart", |
| contextArgs := { |
| timerName := "T_userWatchdog" |
| } |
| }, |
| { |
| stepOrFunctionName := c_EPTF_LGenBase_stepName_entityAborted, |
| contextArgs := omit |
| }, |
| { |
| stepOrFunctionName := "LGenBase: Reset chronometer", |
| contextArgs := { |
| statMeasName := "l_latency" |
| } |
| }, |
| { |
| stepOrFunctionName := "LGenBase: Start chronometer", |
| contextArgs := { |
| statMeasName := "l_latency" |
| } |
| }, |
| { |
| stepOrFunctionName := "LGenBase: Increment variable", |
| contextArgs := { |
| varParams := { |
| varName := "vi_reqSent", |
| paramValue := { |
| intVal := 1 |
| } |
| } |
| } |
| } |
| }, |
| nextStateCalculation := omit, |
| nextState := "initiated" |
| }, |
| { |
| actionList := omit, |
| nextStateCalculation := omit, |
| nextState := omit |
| }, |
| { |
| actionList := omit, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| } |
| } |
| var EPTF_LGenBase_FsmTableDeclarator vl_decl2 := { |
| name := c_fsmName&"2", |
| fsmParams := { |
| { |
| stateList := { |
| "idle", |
| "initiated", |
| "retryAfter" |
| } |
| }, |
| { |
| timerList := { |
| { |
| name := "T_userWatchdog", |
| startValue := 40.000000 |
| }, |
| { |
| name := "T_retryAfter", |
| startValue := 5.000000 |
| } |
| } |
| }, |
| { |
| varList := { |
| { |
| name := "vi_retryAfter", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := FSM |
| }, |
| { |
| name := "vi_reqSent", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_reqSendError", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_reqRecvOk", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_reqRecvNOk", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_respRecvOk", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_respRecvNOk", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vi_timeOut", |
| initValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "vf_rtt", |
| initValue := { |
| floatVal := 0.000000 |
| }, |
| scope := TC |
| } |
| } |
| }, |
| { |
| statHandlerStatList := { |
| { |
| name := "Retry-Afters", |
| providers := { |
| { |
| varList := { |
| "vi_retryAfter" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "ReqSent", |
| providers := { |
| { |
| varList := { |
| "vi_reqSent" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "ReqSentInError", |
| providers := { |
| { |
| varList := { |
| "vi_reqSendError" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "RequestsReceivedOk", |
| providers := { |
| { |
| varList := { |
| "vi_reqRecvOk" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "RequestsReceivedNOk", |
| providers := { |
| { |
| varList := { |
| "vi_reqRecvNOk" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "ResponsesReceivedOk", |
| providers := { |
| { |
| varList := { |
| "vi_respRecvOk" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "ResponsesReceivedNOk", |
| providers := { |
| { |
| varList := { |
| "vi_respRecvNOk" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "timeOuts", |
| providers := { |
| { |
| varList := { |
| "vi_timeOut" |
| } |
| } |
| }, |
| statMethod := "Sum", |
| statResetValue := { |
| intVal := 0 |
| }, |
| scope := TC |
| }, |
| { |
| name := "latency_percentile95", |
| providers := { |
| { |
| statMeas := "l_p95_rtt" |
| } |
| }, |
| statMethod := "Percentile95", |
| statResetValue := { |
| floatVal := 0.000000 |
| }, |
| scope := TC |
| }, |
| { |
| name := "latency_median", |
| providers := { |
| { |
| statMeas := "l_m_rtt" |
| } |
| }, |
| statMethod := "PercentileP", |
| statResetValue := { |
| floatVal := 0.000000 |
| }, |
| scope := TC |
| }, |
| { |
| name := "latency", |
| providers := { |
| { |
| statMeas := "l_d_rtt" |
| } |
| }, |
| statMethod := "Density", |
| statResetValue := { |
| integerlistVal := { |
| 0,0,0,0,0, |
| 0,0,0,0,0, |
| 0,0,0,0,0, |
| 0,0,0,0,0, |
| 0 |
| } |
| }, |
| scope := TC |
| } |
| } |
| }, |
| { |
| statMeasWithParamsList := { |
| { |
| name := "l_latency", |
| providerVarName := "", |
| targetVarName := "vf_rtt", |
| statMeasParams := { |
| statType := chrono |
| }, |
| scope := FSM |
| }, |
| { |
| name := "l_m_rtt", |
| providerVarName := "vf_rtt", |
| targetVarName := "", |
| statMeasParams := { |
| params := { |
| percentileP := { |
| valueP := 0.500000, |
| density := { |
| scale := { |
| min := 0.010000, |
| max := 5.000000, |
| n := 20, |
| scale := logarithmic |
| } |
| } |
| } |
| } |
| }, |
| scope := TC |
| }, |
| { |
| name := "l_p95_rtt", |
| providerVarName := "vf_rtt", |
| targetVarName := "", |
| statMeasParams := { |
| params := { |
| percentile95 := { |
| scale := { |
| min := 0.010000, |
| max := 5.000000, |
| n := 20, |
| scale := logarithmic |
| } |
| } |
| } |
| }, |
| scope := TC |
| }, |
| { |
| name := "l_d_rtt", |
| providerVarName := "vf_rtt", |
| targetVarName := "", |
| statMeasParams := { |
| params := { |
| density := { |
| scale := { |
| min := 0.010000, |
| max := 5.000000, |
| n := 20, |
| scale := logarithmic |
| } |
| } |
| } |
| }, |
| scope := TC |
| } |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| { |
| eventToListen := { |
| bName := "EPTF_CLL_LGenBase", |
| iName := "LGenBase: Start_the_traffic_case!", |
| eventType := fsm |
| }, |
| cellRow := { |
| { |
| actionList := { |
| { |
| stepOrFunctionName := c_EPTF_LGenBase_stepName_recordEntityStart, |
| contextArgs := omit |
| }, |
| { |
| stepOrFunctionName := "LGenBase: StepFunction_timerStart", |
| contextArgs := { |
| timerName := "T_userWatchdog" |
| } |
| }, |
| { |
| stepOrFunctionName := c_EPTF_LGenBase_stepName_entityAborted, |
| contextArgs := omit |
| }, |
| { |
| stepOrFunctionName := "LGenBase: Reset chronometer", |
| contextArgs := { |
| statMeasName := "l_latency" |
| } |
| }, |
| { |
| stepOrFunctionName := "LGenBase: Start chronometer", |
| contextArgs := { |
| statMeasName := "l_latency" |
| } |
| }, |
| { |
| stepOrFunctionName := "LGenBase: Increment variable", |
| contextArgs := { |
| varParams := { |
| varName := "vi_reqSent", |
| paramValue := { |
| intVal := 1 |
| } |
| } |
| } |
| } |
| }, |
| nextStateCalculation := omit, |
| nextState := "initiated" |
| }, |
| { |
| actionList := omit, |
| nextStateCalculation := omit, |
| nextState := omit |
| }, |
| { |
| actionList := omit, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| f_EPTF_LGenBase_init("tc_fsmDecl") |
| |
| var integer v_fsm1 := f_EPTF_LGenBase_declareFSMTable(vl_decl1) |
| var integer v_fsm2 := f_EPTF_LGenBase_declareFSMTable(vl_decl2) |
| if(tsp_EPTF_LGenBaseTestDebug){ |
| log("FSM1: ",f_EPTF_LGenBase_getFSMTable(v_fsm1)) |
| log("FSM2: ",f_EPTF_LGenBase_getFSMTable(v_fsm2)) |
| } |
| if(match(f_EPTF_LGenBase_getFSMTable(v_fsm1),t_EPTF_LGenBaseTest_fsmCompare(c_fsmName, f_EPTF_LGenBase_getFSMTable(v_fsm2)))){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail) |
| log(match(f_EPTF_LGenBase_getFSMTable(v_fsm1),t_EPTF_LGenBaseTest_fsmCompare(c_fsmName, f_EPTF_LGenBase_getFSMTable(v_fsm2)))) |
| } |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| function f_testStep_setverdictFail( |
| in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LGenBase_CT |
| { |
| log(%definitionId&": called."); |
| setverdict(fail); |
| } |
| |
| testcase tc_fsmCancelAllTimers() |
| runs on EPTF_LGenBase_CT |
| { |
| const charstring c_fsmName := "theFsm"; |
| const charstring c_myBehavior := "myBehavior"; |
| const charstring c_eventName_cancelAllTimers := "cancelAllTimers"; |
| const charstring c_eventName_startTimers := "startTimers"; |
| const charstring c_stepName_setverdictFail := "stepName_setverdictFail"; |
| const charstring c_entityType := "entityType"; |
| const charstring c_entityGrp := "entityGrp"; |
| var EPTF_LGenBase_FsmTableDeclarator vl_decl := { |
| name := c_fsmName, |
| fsmParams := { |
| { |
| stateList := { |
| "theState" |
| } |
| }, |
| { |
| timerList := { |
| { |
| name := "T1", |
| startValue := 7.000000 |
| }, |
| { |
| name := "T2", |
| startValue := 5.000000 |
| } |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| { |
| eventToListen := { |
| bName := c_myBehavior, |
| iName := c_eventName_startTimers, |
| eventType := fsm |
| }, |
| cellRow := { |
| { |
| actionList := { |
| { |
| stepOrFunctionName := c_EPTF_LGenBase_stepName_timerStart, |
| contextArgs := {timerName := "T1"} |
| }, |
| { |
| stepOrFunctionName := c_EPTF_LGenBase_stepName_timerStart, |
| contextArgs := {timerName := "T2"} |
| } |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| }, |
| { |
| eventToListen := { |
| bName := c_myBehavior, |
| iName := c_eventName_cancelAllTimers, |
| eventType := fsm |
| }, |
| cellRow := { |
| { |
| actionList := { |
| { |
| stepOrFunctionName := c_EPTF_LGenBase_stepName_cancelAllTimers, |
| contextArgs := omit |
| } |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| }, |
| { |
| eventToListen := { |
| bName := c_EPTF_LGenBase_specialBName_timerTimeout, |
| iName := "T1", |
| eventType := fsm |
| }, |
| cellRow := { |
| { |
| actionList := { |
| { |
| stepOrFunctionName := c_stepName_setverdictFail, |
| contextArgs := omit |
| } |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| }, |
| { |
| eventToListen := { |
| bName := c_EPTF_LGenBase_specialBName_timerTimeout, |
| iName := "T2", |
| eventType := fsm |
| }, |
| cellRow := { |
| { |
| actionList := { |
| { |
| stepOrFunctionName := c_stepName_setverdictFail, |
| contextArgs := omit |
| } |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| f_EPTF_LGenBase_init(""); |
| |
| var integer vl_bIdx := f_EPTF_LGenBase_declareBehaviorType(c_myBehavior, -1, null, null, null) |
| var integer vl_dummyInt := f_EPTF_LGenBase_declareEntityType(c_entityType,{c_myBehavior}); |
| vl_dummyInt := f_EPTF_LGenBase_createEntityGroup({c_entityGrp,c_entityType,1}); |
| |
| var integer v_eventIdx_cancelAllTimers := |
| f_EPTF_LGenBase_declareFsmEvent(c_myBehavior, c_eventName_cancelAllTimers) |
| var integer v_eventIdx_startTimers := |
| f_EPTF_LGenBase_declareFsmEvent(c_myBehavior, c_eventName_startTimers) |
| |
| vl_dummyInt := f_EPTF_LGenBase_declareStep(c_myBehavior, {c_stepName_setverdictFail,refers(f_testStep_setverdictFail)}) |
| |
| var integer vl_fsm := f_EPTF_LGenBase_declareFSMTable(vl_decl) |
| |
| vl_dummyInt := f_EPTF_LGenBase_activateFsm(pl_eIdx:= 0, pl_tIdx:= vl_fsm, pl_sIdx:=0, pl_tcIdx:= -1) |
| |
| timer T; |
| T.start(1.0); |
| T.timeout; |
| f_EPTF_LGenBase_dispatchEvent({{vl_bIdx, v_eventIdx_startTimers, {0,0}, omit},{}}); |
| T.start(1.0); |
| T.timeout; |
| f_EPTF_LGenBase_dispatchEvent({{vl_bIdx, v_eventIdx_cancelAllTimers, {0,0}, omit},{}}); |
| T.start(10.0); |
| T.timeout; |
| setverdict(pass); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| //This TestCase tests if the f_EPTF_LGenBase_declareFSMTables() function can create |
| //the FSMTables given in its argument |
| // - it uses dummy FSM tables |
| // - the verdict will be pass only if all the FSMTables are created successfully |
| testcase tc_EPTF_LGenBase_Test_declareFSMTables() |
| runs on EPTF_LGenBase_CT{ |
| var EPTF_LGenBase_FsmTableDeclaratorList vl_EPTF_LGenBase_FsmTableDeclaratorList :={ |
| { |
| name := "start", |
| fsmParams := { |
| {stateList := {"idle"}} |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{ |
| {c_EPTF_LGenBase_stepName_testFinished, omit} |
| }, omit, omit} |
| } |
| } |
| } |
| } |
| }, |
| { |
| name := "stop", |
| fsmParams := { |
| {stateList := {"idle"}} |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{ |
| {c_EPTF_LGenBase_stepName_testFinished, omit} |
| }, omit, omit} |
| } |
| } |
| } |
| } |
| } |
| } |
| f_EPTF_LGenBase_init("LGenBase_declareFSMTables"); |
| |
| var EPTF_IntegerList vl_FSMTableIdx_List := |
| f_EPTF_LGenBase_declareFSMTables(vl_EPTF_LGenBase_FsmTableDeclaratorList); |
| |
| for ( var integer i := 0; i < sizeof(vl_FSMTableIdx_List) ; i := i+1 ){ |
| if (vl_FSMTableIdx_List[i] == -1){ |
| setverdict(fail); |
| break; |
| } |
| } |
| setverdict(pass); |
| f_EPTF_Base_cleanup_CT(); |
| |
| } |
| |
| //this function is for the testcase |
| //tc_EPTF_LGenBase_Test_FsmGetFunctions |
| function f_EPTF_LGenBase_step_forFsmGetFunctionsTc(in EPTF_LGenBase_TestStepArgs pl_args) |
| runs on fsmGetFunctions_CT |
| { |
| //testing f_EPTF_LGenBase_getFsmIdxOfTc |
| //the return value of the function should be equal |
| //with the index of the FSM created above |
| var integer vl_tcIdx := f_EPTF_LGenBase_tcIdxOfStep(pl_args) |
| if(f_EPTF_LGenBase_getFsmIdxOfTc(vl_tcIdx) != v_fsmIndex){ |
| setverdict ( fail ); |
| } |
| //testing f_EPTF_LGenBase_getFsmNameOfTc |
| //(and f_EPTF_LGenBase_getFsmName) |
| //the return value of the function should be equal |
| //with the name of the FSM created above |
| if (f_EPTF_LGenBase_getFsmNameOfTc(vl_tcIdx) != "testFSM"){ |
| setverdict ( fail ); |
| } |
| |
| //testing f_EPTF_LGenBase_getFsmIndexByCtxIdx |
| if (f_EPTF_LGenBase_getFsmIndexByCtxIdx(pl_args.eIdx, pl_args.refContext.fCtxIdx) != v_fsmIndex){ |
| setverdict ( fail ); |
| } |
| //testing f_EPTF_LGenBase_getFsmNameByCtxIdx |
| if (f_EPTF_LGenBase_getFsmNameByCtxIdx(pl_args.eIdx, pl_args.refContext.fCtxIdx) != "testFSM"){ |
| setverdict ( fail ); |
| } |
| |
| //testing f_EPTF_LGenBase_getFsmIndexByStepArgs |
| if (f_EPTF_LGenBase_getFsmIndexByStepArgs(pl_args) != v_fsmIndex){ |
| setverdict ( fail ); |
| } |
| //testing f_EPTF_LGenBase_getFsmNameByStepArgs |
| if (f_EPTF_LGenBase_getFsmNameByStepArgs(pl_args) != "testFSM"){ |
| setverdict ( fail ); |
| } |
| |
| setverdict ( pass ); |
| } |
| |
| //this component type is for the testcase |
| //tc_EPTF_LGenBase_Test_FsmGetFunctions |
| type component fsmGetFunctions_CT extends EPTF_LGenBase_CT{ |
| var integer v_fsmIndex |
| } |
| |
| //This TestCase tests if all the functions below works properly |
| // f_EPTF_LGenBase_getFsmNameOfTc |
| // f_EPTF_LGenBase_getFsmIdxOfTc |
| // f_EPTF_LGenBase_getFsmIndexByCtxIdx |
| // f_EPTF_LGenBase_getFsmNameByCtxIdx |
| // f_EPTF_LGenBase_getFsmIndexByStepArgs |
| // f_EPTF_LGenBase_getFsmNameByStepArgs |
| // f_EPTF_LGenBase_getFsmName |
| // |
| // - the verdict will be pass only if all the functions are working properly |
| testcase tc_EPTF_LGenBase_Test_FsmGetFunctions() |
| runs on fsmGetFunctions_CT{ |
| f_EPTF_LGenBase_init("test"); |
| var integer |
| v_bIdx := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| var integer |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i1") |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i3") |
| v_dummyInt := f_EPTF_LGenBase_declareStep("b1", {"forFsmGetFunctionsTc", refers( f_EPTF_LGenBase_step_forFsmGetFunctionsTc )}) |
| var integer |
| v_iIdx := f_EPTF_LGenBase_declareFsmEvent("b1", "i2") |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 25}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg1", eType := "Entity_Tc_A", eCount := 125}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg2", eType := "Entity_Tc_A", eCount := 200}) |
| |
| f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "testFSM0", |
| fsmParams := { |
| {stateList := {"idle"}} |
| ,{varList := { |
| {name := "vf_callCounter", initValue := {intVal := 0}, scope := TC} |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := { bName := "b1", iName := "i2", eventType := fsm }, |
| cellRow := { |
| //state==idle |
| {actionList := { |
| {stepOrFunctionName := c_EPTF_LGenBase_stepName_trafficFailed, contextArgs := omit} |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm //XCAPget_DOT:} |
| ) |
| v_fsmIndex := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "testFSM", |
| fsmParams := { |
| {stateList := {"idle"}} |
| ,{varList := { |
| {name := "vf_callCounter", initValue := {intVal := 0}, scope := TC} |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := { bName := "b1", iName := "i2", eventType := fsm }, |
| cellRow := { |
| //state==idle |
| {actionList := { |
| {stepOrFunctionName := "forFsmGetFunctionsTc", contextArgs := omit} |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm //XCAPget_DOT:} |
| ) |
| |
| f_EPTF_LGenBase_declareTcType2( |
| { |
| name := "testTC0", |
| fsmName := "testFSM0", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }); |
| |
| var integer |
| v_tcTypeIdx := f_EPTF_LGenBase_declareTcType2( |
| { |
| name := "testTC", |
| fsmName := "testFSM", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }); |
| |
| var integer |
| v_scIdx := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := "sc1", |
| tcList := { |
| { tcName := "testTC0", |
| tcParamsList := { |
| {tcTypeName := "testTC0"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := false}, |
| {target := {cpsToReach := 1111.0}} |
| } |
| }, |
| { tcName := "tc1", |
| tcParamsList := { |
| {tcTypeName := "testTC"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {cpsToReach := 1111.0}} |
| } |
| } |
| }, |
| scParamsList := { |
| {enabled := true} |
| } |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg1","sc1"}, false) |
| //this event calls the step function f_EPTF_LGenBase_step_forFsmGetFunctionsTc |
| //the verdict will be set in the function |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {26, 1}, omit},{}}); |
| |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| type component EPTF_LGenBase_startDelay_CT extends EPTF_LGenBase_Test_CT{ |
| var float c_delay := 5.0; |
| var boolean v_testStarted := false; |
| } |
| |
| function f_EPTF_LGenBase_Test_tcStartedListener( |
| EPTF_LGenBase_ReportedEventDescriptor pl_event, |
| EPTF_IntegerList pl_listenerArgs) |
| runs on EPTF_LGenBase_startDelay_CT{ |
| if(tsp_EPTF_LGenBaseTestDebug) {log(%definitionId)} |
| v_testStarted := true; |
| } |
| |
| function f_EPTF_LGenBase_Test_startDelay_init( in float pl_cpsToReach ) |
| runs on EPTF_LGenBase_startDelay_CT |
| { |
| f_EPTF_LGenBase_init("actionsPerCondition"); |
| v_dummyInt := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 2}) |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable({ |
| name := "stop", |
| fsmParams := { |
| {stateList := {"idle"}} |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{ |
| {c_EPTF_LGenBase_stepName_testFinished, omit} |
| }, omit, omit} |
| } |
| } |
| } |
| } |
| }) |
| v_dummyInt := f_EPTF_LGenBase_addGeneralEventListener( |
| c_EPTF_LGenBase_bIdx, |
| c_EPTF_LGenBase_inputIdx_testMgmt_startTC, |
| refers(f_EPTF_LGenBase_Test_tcStartedListener), {}) |
| v_dummyInt := f_EPTF_LGenBase_declareTcType2({ |
| name := "TC_Succ", |
| fsmName := "stop", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := "Scenario_Simple", |
| tcList := { |
| { |
| tcName := "TC_A0", |
| tcParamsList := { |
| {tcTypeName := "TC_Succ"}, |
| {startDelay := c_delay}, |
| {target := {cpsToReach := pl_cpsToReach}}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true} |
| } |
| } |
| }, |
| |
| scParamsList := {} |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg0", "Scenario_Simple"}, false) |
| f_EPTF_LGenBase_startTrafficCaseByIdx(0) |
| } |
| |
| // purpose: test start_delay TR's correction |
| // check: new cps value set, but the execution not started until start delay expired |
| testcase tc_EPTF_LGenBase_Test_startDelay_cps_change_R4() |
| runs on EPTF_LGenBase_startDelay_CT{ |
| f_EPTF_LGenBase_Test_startDelay_init(20.0); |
| |
| |
| timer t_dummy; // to give time for TC setup |
| t_dummy.start(0.5); |
| t_dummy.timeout; |
| |
| f_EPTF_LGenBase_setCPS(0, pl_newCps := 10.0); |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| if(v_testStarted){ |
| setverdict(fail) |
| } |
| |
| t_dummy.start(c_delay); |
| t_dummy.timeout; |
| |
| if(not v_testStarted){ |
| setverdict(fail) |
| } |
| |
| setverdict (pass); |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| // purpose: test start_delay TR's correction |
| // check: the starting cps value is 0, so no event enqueued with the start of the tc |
| // later new cps value set, and execution starts after start_delay is expired |
| testcase tc_EPTF_LGenBase_Test_startDelay_start_with_zero_cps_R4() |
| runs on EPTF_LGenBase_startDelay_CT{ |
| f_EPTF_LGenBase_Test_startDelay_init(0.0); |
| |
| timer t_dummy; // to give time for TC setup |
| t_dummy.start(0.5); |
| t_dummy.timeout; |
| |
| if(v_testStarted){ |
| setverdict(fail) |
| } |
| |
| f_EPTF_LGenBase_setCPS(0, pl_newCps := 20.0); |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| if(v_testStarted){ |
| setverdict(fail) |
| } |
| |
| t_dummy.start(c_delay); |
| t_dummy.timeout; |
| |
| if(not v_testStarted){ |
| setverdict(fail) |
| } |
| |
| setverdict (pass); |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| // purpose: test start_delay TR's correction |
| // check: zero cps value set during the test execution -> event removed from the queue |
| // later a nonzero cps value set, and execution starts after start_delay is expired |
| testcase tc_EPTF_LGenBase_Test_startDelay_set_zero_cps_R4() |
| runs on EPTF_LGenBase_startDelay_CT{ |
| f_EPTF_LGenBase_Test_startDelay_init(20.0); |
| |
| timer t_dummy; // to give time for TC setup |
| t_dummy.start(0.5); |
| t_dummy.timeout; |
| |
| // test the TR: after setting a cps the traffic immediately starts |
| f_EPTF_LGenBase_setCPS(0, pl_newCps := 0.0); |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| if(v_testStarted){ |
| setverdict(fail) |
| } |
| |
| f_EPTF_LGenBase_setCPS(0, pl_newCps := 20.0); |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| if(v_testStarted){ |
| setverdict(fail) |
| } |
| |
| t_dummy.start(c_delay); |
| t_dummy.timeout; |
| |
| if(not v_testStarted){ |
| setverdict(fail) |
| } |
| |
| setverdict (pass); |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| // purpose: test start_delay TR's correction |
| // check: zero cps value set during the test execution -> event removed from the queue |
| // later a nonzero cps value set when the start_delay exired, execution must start immediately |
| testcase tc_EPTF_LGenBase_Test_startDelay_expired_R4() |
| runs on EPTF_LGenBase_startDelay_CT{ |
| f_EPTF_LGenBase_Test_startDelay_init(20.0); |
| |
| timer t_dummy; // to give time for TC setup |
| t_dummy.start(0.5); |
| t_dummy.timeout; |
| |
| f_EPTF_LGenBase_setCPS(0, pl_newCps := 0.0); |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| if(v_testStarted){ |
| setverdict(fail) |
| } |
| |
| t_dummy.start(c_delay); |
| t_dummy.timeout; |
| |
| f_EPTF_LGenBase_setCPS(0, pl_newCps := 20.0); |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| if(not v_testStarted){ |
| setverdict(fail) |
| } |
| |
| setverdict (pass); |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| // purpose: test start_delay and pause interaction |
| // after pushing "pause" and "tc_start" the TC should not run until start_delay is expired |
| testcase tc_EPTF_LGenBase_Test_startDelay_pause_R4() |
| runs on EPTF_LGenBase_startDelay_CT{ |
| f_EPTF_LGenBase_Test_startDelay_init(20.0); |
| |
| timer t_dummy; // to give time for TC setup |
| t_dummy.start(0.5); |
| t_dummy.timeout; |
| |
| if(v_testStarted){ |
| setverdict(fail, "TC started immediately at the beginning") |
| } |
| |
| f_EPTF_LGenBase_pauseTrafficCase("eg0", "Scenario_Simple", "TC_A0") |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| if(v_testStarted){ |
| setverdict(fail, "TC started after pause") |
| } |
| |
| f_EPTF_LGenBase_startTrafficCase("eg0", "Scenario_Simple", "TC_A0") |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| if(v_testStarted){ |
| setverdict(fail, "TC started immediately after resume") |
| } |
| |
| t_dummy.start(c_delay); |
| t_dummy.timeout; |
| |
| if(not v_testStarted){ |
| setverdict(fail, "TC not started after start delay expiry") |
| } |
| |
| setverdict (pass); |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| function f_EPTF_LGenBase_Test_nextStateCalcTestFn( |
| in integer eIdx, |
| in integer fIdx, |
| in EPTF_IntegerList contextArgs, |
| in EPTF_LGenBase_FsmTableCellReference pl_cell, |
| in EPTF_IntegerList pl_stepArgs //supply args to actions |
| ) |
| runs on EPTF_LGenBase_Test_CT |
| return integer{ |
| //log("contextArgs: ",contextArgs) |
| //log("pl_stepArgs: ",pl_stepArgs) |
| var integer vl_state := f_EPTF_LGenBase_getFsmStateIdxByCtxIdx(eIdx, fIdx) |
| var EPTF_LGenBase_TestStepArgs vl_args := c_EPTF_LGenBase_emptyTestStepArgs |
| vl_args.eIdx := eIdx |
| vl_args.refContext.fCtxIdx := fIdx |
| vl_args.refContext.fRefArgs := contextArgs |
| vl_args.stepArgs := pl_stepArgs |
| select( vl_state ) |
| { |
| case ( 0 ){ |
| //varid |
| vl_state := vl_state + 1 |
| var integer vl_varId := f_EPTF_LGenBase_fsmVarIdFromStep(vl_args) |
| if(0 > vl_varId){ |
| setverdict ( fail, "Invalid variable ID" ) |
| } |
| var EPTF_Var_DirectContent vl_content |
| f_EPTF_Var_getContent(vl_varId, vl_content) |
| if(vl_content.intVal != 0){ |
| setverdict ( fail, "The content of the variable should be 0" ) |
| } |
| } |
| case ( 1 ){ |
| //varParams |
| vl_state := vl_state + 1 |
| var integer vl_varId |
| var EPTF_Var_DirectContent vl_content, vl_contentParam |
| f_EPTF_LGenBase_fsmVarParamsFromStep(vl_args, vl_varId, vl_contentParam) |
| f_EPTF_Var_getContent(vl_varId, vl_content) |
| if(vl_content != vl_contentParam){ |
| setverdict ( fail, "The received parameter should equal the content of the variable:", |
| log2str( match(vl_content,vl_contentParam) ) ) |
| } |
| } |
| case ( 2 ){ |
| vl_state := 0 |
| if({3,5,1}==contextArgs){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail,log2str(match({3,5,1},contextArgs))) |
| } |
| } |
| case else{ |
| //There shouldn't be any other state |
| setverdict(inconc) |
| } |
| } |
| |
| return vl_state |
| } |
| |
| testcase tc_EPTF_LGenBase_Test_nextStateParams() |
| runs on EPTF_LGenBase_Test_CT{ |
| f_EPTF_LGenBase_init("nextStateParams"); |
| const integer c_entities := 6 |
| var integer v_behav := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("et1", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({"eg1", "et1", c_entities}) |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "event") |
| v_dummyInt := f_EPTF_LGenBase_declareFunction( |
| "nextStateCalcTestFn", |
| {nextStateCalcFunction := refers(f_EPTF_LGenBase_Test_nextStateCalcTestFn)}) |
| const EPTF_LGenBase_FsmTableDeclarator c_FSM := { |
| name := "FlexFsm1", |
| fsmParams := |
| { |
| {varList := |
| {{ |
| name := "var1", |
| initValue := {intVal := 9}, |
| scope := FSM |
| }, |
| { |
| name := "var2", |
| initValue := {intVal := 9}, |
| scope := FSM |
| }} |
| }, |
| {stateList := {"idle", "busy","third"}} |
| }, |
| table := { |
| extendedTable := { |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","event", fsm} } |
| }}, |
| cellRow := { extStatedCellRow := { |
| { |
| inState := {state := "idle"}, |
| cell := { |
| {{"LGenBase: Set variable",{varParams := {"var1",{intVal := 0}}}}}, |
| {fnName := "nextStateCalcTestFn", argsList := {varNames := {"var1", "var2"}}}} |
| }, |
| { |
| inState := {state := "busy"}, |
| cell := { |
| {{"LGenBase: Set variable",{varParams := {"var1",{intVal := 1}}}}}, |
| {fnName := "nextStateCalcTestFn", argsList := {varParams := {"var1",{intVal := 1}}}}} |
| }, |
| { |
| inState := {state := "third"}, |
| cell := { |
| {{"LGenBase: Set variable",{varParams := {"var1",{intVal := 2}}}}}, |
| {fnName := "nextStateCalcTestFn", argsList := {stepContextArgs := {3,5,1}}}} |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable(c_FSM) |
| f_EPTF_LGenBase_activateFsm(1, 0, 0, -1) |
| var EPTF_LGenBase_ReportedEventDescriptor vl_event := c_EPTF_LGenBase_emptyReportedEventDescriptor |
| vl_event.event.bIdx := v_behav |
| vl_event.event.iIdx := 0 |
| vl_event.event.target.eIdx := 1 |
| vl_event.event.target.fsmCtxIdx := 0 |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| group FsmStateGetFunctions{ |
| function f_EPTF_LGenBase_step_forFsmStateGetFunctionsTc(in EPTF_LGenBase_TestStepArgs pl_args) |
| runs on fsmStateGetFunctions_CT |
| { |
| //testing f_EPTF_LGenBase_getFsmStateIdxByCtxIdx |
| //the return value of the function should be equal with the |
| //value in the pl_args.refContext.fRefArgs[0] parameter |
| var integer vl_stateIdx := f_EPTF_LGenBase_getFsmStateIdxByCtxIdx(pl_args.eIdx, pl_args.refContext.fCtxIdx); |
| if (vl_stateIdx != pl_args.refContext.fRefArgs[0]){ |
| setverdict ( fail ); |
| } |
| |
| //testing f_EPTF_LGenBase_getFsmStateNameByCtxIdx |
| //the return value of the function should be equal with the |
| //value depending on the pl_args.refContext.fRefArgs[0] parameter |
| var charstring vl_stateNameFromGetter := f_EPTF_LGenBase_getFsmStateNameByCtxIdx(pl_args.eIdx, pl_args.refContext.fCtxIdx); |
| var charstring vl_stateName; |
| if (pl_args.refContext.fRefArgs[0] == 0){ |
| vl_stateName := "first"; |
| } |
| if (pl_args.refContext.fRefArgs[0] == 1){ |
| vl_stateName := "second"; |
| } |
| if (vl_stateNameFromGetter != vl_stateName){ |
| setverdict ( fail ); |
| } |
| |
| //testing f_EPTF_LGenBase_getFsmStateIdxByStepArgs |
| //the return value of the function should be equal with the |
| //value in the pl_args.refContext.fRefArgs[0] parameter |
| vl_stateIdx := f_EPTF_LGenBase_getFsmStateIdxByStepArgs(pl_args); |
| if (vl_stateIdx != pl_args.refContext.fRefArgs[0]){ |
| setverdict ( fail ); |
| } |
| |
| //testing f_EPTF_LGenBase_getFsmStateNameByStepArgs |
| //the return value of the function should be equal with the |
| //value depending on the pl_args.refContext.fRefArgs[0] parameter |
| vl_stateNameFromGetter := f_EPTF_LGenBase_getFsmStateNameByStepArgs(pl_args); |
| if (vl_stateNameFromGetter != vl_stateName){ |
| setverdict ( fail ); |
| } |
| |
| setverdict ( pass ); |
| } |
| |
| type component fsmStateGetFunctions_CT extends EPTF_LGenBase_CT{ |
| } |
| |
| //This TestCase tests if all the functions below works properly |
| // f_EPTF_LGenBase_getFsmStateNameByCtxIdx |
| // f_EPTF_LGenBase_getFsmStateIdxByCtxIdx |
| // f_EPTF_LGenBase_getFsmStateNameByStepArgs |
| // f_EPTF_LGenBase_getFsmStateIdxByStepArgs |
| // |
| // - the verdict will be pass only if all the functions are working properly |
| testcase tc_EPTF_LGenBase_Test_FsmStateGetFunctions() |
| runs on fsmStateGetFunctions_CT{ |
| f_EPTF_LGenBase_init("test"); |
| var integer |
| v_bIdx := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| var integer |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i1") |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i3") |
| v_dummyInt := f_EPTF_LGenBase_declareStep("b1", {"forFsmStateGetFunctionsTc", refers( f_EPTF_LGenBase_step_forFsmStateGetFunctionsTc )}) |
| var integer |
| v_iIdx := f_EPTF_LGenBase_declareFsmEvent("b1", "i2") |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 25}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg1", eType := "Entity_Tc_A", eCount := 125}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg2", eType := "Entity_Tc_A", eCount := 200}) |
| |
| var integer v_fsmIndex := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "testFSM", |
| fsmParams := { |
| {stateList := {"first", "second"}} |
| ,{varList := { |
| {name := "vf_callCounter", initValue := {intVal := 0}, scope := TC} |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := { bName := "b1", iName := "i2", eventType := fsm }, |
| cellRow := { |
| //state==first |
| {actionList := { |
| {stepOrFunctionName := "forFsmStateGetFunctionsTc", |
| contextArgs := { |
| stepContextArgs := {0} |
| } |
| } |
| }, |
| nextStateCalculation := omit, |
| nextState := "second" |
| }, |
| //state==second |
| {actionList := { |
| {stepOrFunctionName := "forFsmStateGetFunctionsTc", |
| contextArgs := { |
| stepContextArgs := {1} |
| } |
| } |
| }, |
| nextStateCalculation := omit, |
| nextState := "first" |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm |
| ) |
| |
| var integer |
| v_tcTypeIdx := f_EPTF_LGenBase_declareTcType2( |
| { |
| name := "testTC", |
| fsmName := "testFSM", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }); |
| |
| var integer |
| v_scIdx := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := "sc1", |
| tcList := { |
| { tcName := "tc1", |
| tcParamsList := { |
| {tcTypeName := "testTC"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {cpsToReach := 1111.0}} |
| } |
| } |
| }, |
| scParamsList := { |
| {enabled := true} |
| } |
| }) |
| |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg1","sc1"}, false) |
| //this event calls the step function f_EPTF_LGenBase_step_forFsmStateGetFunctionsTc |
| //the verdict will be set in the function |
| f_EPTF_LGenBase_dispatchEvent({{v_bIdx, v_iIdx, {26, 0}, omit},{}}); |
| |
| timer t_wait; |
| t_wait.start( 0.5 ); |
| t_wait.timeout; |
| |
| f_EPTF_Base_cleanup_CT() |
| } |
| } |
| |
| group NameOfExpiredTimer{ |
| function f_EPTF_LGenBase_step_forNameOfExpiredTimerTc(in EPTF_LGenBase_TestStepArgs pl_args) |
| runs on NameOfExpiredTimer_CT |
| { |
| //testing f_EPTF_LGenBase_getNameOfExpiredTimer |
| //the return value of the function should be "timer_2" |
| if (f_EPTF_LGenBase_getNameOfExpiredTimer(pl_args) != "timer_2"){ |
| setverdict ( fail, match(f_EPTF_LGenBase_getNameOfExpiredTimer(pl_args), "timer_2")); |
| } |
| setverdict(pass); |
| } |
| |
| type component NameOfExpiredTimer_CT extends EPTF_LGenBase_CT{ |
| } |
| |
| //This TestCase tests if the f_EPTF_LGenBase_getNameOfExpiredTimer |
| //function is working properly |
| // |
| // - the verdict will be pass if the function is working properly |
| testcase tc_EPTF_LGenBase_Test_NameOfExpiredTimer() |
| runs on NameOfExpiredTimer_CT{ |
| f_EPTF_LGenBase_init("test"); |
| var integer |
| vl_bIdx := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| var integer |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i1") |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i3") |
| v_dummyInt := f_EPTF_LGenBase_declareStep("b1", {"forNameOfExpiredTimerTc", refers( f_EPTF_LGenBase_step_forNameOfExpiredTimerTc )}) |
| var integer |
| vl_iIdx := f_EPTF_LGenBase_declareFsmEvent("b1", "i2") |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 25}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg1", eType := "Entity_Tc_A", eCount := 125}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg2", eType := "Entity_Tc_A", eCount := 200}) |
| |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "timerFSM", |
| fsmParams := { |
| {stateList := {"first", "second"}}, |
| {timerList := {{ |
| name := "timer_1", |
| startValue := 0.1 |
| }, |
| { name := "timer_2", |
| startValue := 0.2 |
| }, |
| { name := "timer_3", |
| startValue := 0.3 |
| } |
| } |
| } |
| },//fsmParams |
| table := { |
| extendedTable := { |
| { |
| events2Listen := {events := { |
| { singleEvent := { bName := "b1", iName := "i2", eventType := fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "first"}, |
| cell := { |
| actionList := |
| {{ stepOrFunctionName := "LGenBase: StepFunction_timerStart", |
| contextArgs := {timerName := "timer_2"}}}, |
| nextStateCalculation := omit, |
| nextState := "second"} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { |
| { singleEvent := { bName := "Special behavior for timeout reporting", iName := "timer_2", eventType := fsm}} |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "second"}, |
| cell := { |
| actionList := |
| {{stepOrFunctionName := "forNameOfExpiredTimerTc",contextArgs := omit}}, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm |
| ) |
| f_EPTF_LGenBase_activateFsm(26, 0, 0, -1); |
| //this event calls the step function f_EPTF_LGenBase_step_forNameOfExpiredTimerTc |
| //the verdict will be set in the function |
| f_EPTF_LGenBase_dispatchEvent({{vl_bIdx, vl_iIdx, {26, 0}, omit},{}}); |
| timer t_wait; |
| t_wait.start( 0.5 ); |
| t_wait.timeout; |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| //This TestCase tests if the f_EPTF_LGenBase_getNameOfExpiredTimer |
| //function is working properly when it is called with bad parameters. |
| // |
| // - the verdict will be pass if the function is working properly |
| testcase tc_EPTF_LGenBase_Test_NameOfExpiredTimer_noTimer() |
| runs on NameOfExpiredTimer_CT{ |
| f_EPTF_LGenBase_init("test"); |
| |
| var integer |
| vl_bIdx := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| var integer |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i1") |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i3") |
| v_dummyInt := f_EPTF_LGenBase_declareStep("b1", {"forNameOfExpiredTimerTc", refers( f_EPTF_LGenBase_step_forNameOfExpiredTimerTc )}) |
| var integer |
| vl_iIdx := f_EPTF_LGenBase_declareFsmEvent("b1", "i2") |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 25}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg1", eType := "Entity_Tc_A", eCount := 125}) |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg2", eType := "Entity_Tc_A", eCount := 200}) |
| |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "timerFSM", |
| fsmParams := { |
| {stateList := {"first", "second"}}, |
| {timerList := {{ |
| name := "timer_1", |
| startValue := 0.1 |
| }, |
| { name := "timer_2", |
| startValue := 0.2 |
| }, |
| { name := "timer_3", |
| startValue := 0.3 |
| } |
| } |
| } |
| },//fsmParams |
| table := { |
| extendedTable := { |
| { |
| events2Listen := {events := { |
| { singleEvent := { bName := "b1", iName := "i2", eventType := fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "first"}, |
| cell := { |
| actionList := |
| {{ stepOrFunctionName := "LGenBase: StepFunction_timerStart", |
| contextArgs := {timerName := "timer_2"}}}, |
| nextStateCalculation := omit, |
| nextState := "second"} |
| } |
| } |
| } |
| }, |
| { |
| events2Listen := {events := { |
| { singleEvent := { bName := "Special behavior for timeout reporting", iName := "timer_2", eventType := fsm}} |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "second"}, |
| cell := { |
| actionList := |
| {{stepOrFunctionName := "forNameOfExpiredTimerTc",contextArgs := omit}}, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm |
| ) |
| f_EPTF_LGenBase_activateFsm(26, 0, 0, -1); |
| |
| //creating a not correct test step arg when there is no timer in it |
| var EPTF_LGenBase_TestStepArgs vl_testArgs; |
| vl_testArgs.eIdx := 26; |
| vl_testArgs.refContext.fCtxIdx := 0; |
| vl_testArgs.stepArgs := {}; |
| var charstring vl_nameOfTimer := f_EPTF_LGenBase_getNameOfExpiredTimer(vl_testArgs); |
| |
| if (vl_nameOfTimer == ""){ |
| setverdict ( pass, "No errors when the timer is undefined in the test step args." ); |
| } |
| else{ |
| setverdict ( pass ); |
| } |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| } |
| |
| group ZeroCPSTest { |
| type component EPTF_LGenBase_ZeroCPSTest_CT extends EPTF_LGenBase_Test_CT{ |
| var boolean v_testZeroCPSTest_TC := false; |
| var boolean v_testZeroCPSTest_SC := false; |
| } |
| |
| const charstring c_LGenBase_Test_setZeroCPSStepName := "setZeroCPSStepName" |
| function f_EPTF_LGenBase_step_setZeroCPS(in EPTF_LGenBase_TestStepArgs pl_args) |
| runs on EPTF_LGenBase_Test_CT |
| { |
| var charstring vl_eGrpName, vl_scName, vl_tcName; |
| f_EPTF_LGenBase_trafficCaseIdNames(0, vl_eGrpName, vl_scName, vl_tcName) |
| f_EPTF_LGenBase_setCPSByNames(vl_eGrpName, vl_scName, vl_tcName, 0.0) |
| f_EPTF_LGenBase_setScenarioCPS(vl_eGrpName, "Scenario_Weighted", 0.0) |
| } |
| |
| function f_EPTF_LGenBase_Test_ZeroCPSTest_checkCleanup() |
| runs on EPTF_LGenBase_ZeroCPSTest_CT{ |
| setverdict(pass) |
| } |
| |
| function f_EPTF_LGenBase_Test_ZeroCPSTest_init() |
| runs on EPTF_LGenBase_ZeroCPSTest_CT |
| { |
| const charstring c_eGrpName := "eg0" |
| const charstring c_scNameWeighted :="Scenario_Weighted" |
| const charstring c_tcName := "testTC" |
| f_EPTF_LGenBase_init("actionsPerCondition"); |
| v_testZeroCPSTest_TC := false; |
| v_testZeroCPSTest_SC := false; |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_LGenBase_Test_ZeroCPSTest_checkCleanup)); |
| f_EPTF_Base_setDTEHandling(false); |
| |
| v_dummyInt := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := c_eGrpName, eType := "Entity_Tc_A", eCount := 5}) |
| v_dummyInt := f_EPTF_LGenBase_declareStep("b1",{c_LGenBase_Test_setZeroCPSStepName, refers(f_EPTF_LGenBase_step_setZeroCPS)}) |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable({ |
| name := "stop", |
| fsmParams := { |
| {stateList := {"idle"}} |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{ |
| {c_LGenBase_Test_setZeroCPSStepName, omit}, |
| {c_EPTF_LGenBase_stepName_testFinished, omit} |
| }, omit, omit} |
| } |
| } |
| } |
| } |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareTcType2({ |
| name := "TC_Succ", |
| fsmName := "stop", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := "Scenario_Simple", |
| tcList := { |
| { |
| tcName := "TC_A0", |
| tcParamsList := { |
| {tcTypeName := "TC_Succ"}, |
| {target := {cpsToReach := 0.0}}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true} |
| } |
| } |
| }, |
| |
| scParamsList := {} |
| }) |
| |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg0", "Scenario_Simple"}, false) |
| |
| |
| f_EPTF_LGenBase_startTrafficCaseByIdx(0) |
| |
| var charstring vl_eGrpName, vl_scName, vl_tcName; |
| f_EPTF_LGenBase_trafficCaseIdNames(0, vl_eGrpName, vl_scName, vl_tcName) |
| f_EPTF_LGenBase_setCPSByNames(vl_eGrpName, vl_scName, vl_tcName, 10.0) |
| |
| //Weighted scenario |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := c_scNameWeighted, |
| tcList := { |
| { tcName := "statTC0", |
| tcParamsList := { |
| {tcTypeName := "TC_Succ"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {trafficWeight := 0.5}} |
| } |
| }, |
| { tcName := c_tcName, |
| tcParamsList := { |
| {tcTypeName := "TC_Succ"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {trafficWeight := 0.5}} |
| } |
| } |
| }, |
| scParamsList := { |
| {weightedScData := { |
| cpsToReach := 0.0, |
| lockCPS := false, |
| deterministicMix := false, |
| scheduler := omit |
| } |
| }, |
| {enabled := true} |
| } |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({c_eGrpName, c_scNameWeighted},false) |
| |
| f_EPTF_LGenBase_startWeightedScenario(c_eGrpName, c_scNameWeighted); |
| f_EPTF_LGenBase_setScenarioCPS(c_eGrpName, c_scNameWeighted, 10.0); |
| } |
| |
| // purpose: test if the CPS is set to 0 in a test step, f_EPTF_LGenBase_burstPreCalcCS does not stp with an error |
| // test of artifact: support #1365576 CLL: DTE in f_EPTF_LGenBase_burstPreCalcCS / Gábor Bettesch |
| testcase tc_EPTF_LGenBase_Test_ZeroCPSTest() |
| runs on EPTF_LGenBase_ZeroCPSTest_CT{ |
| const charstring c_eGrpName := "eg0" |
| const charstring c_scNameWeighted :="Scenario_Weighted" |
| |
| f_EPTF_LGenBase_Test_ZeroCPSTest_init(); |
| |
| |
| timer t_dummy; // to give time for TC setup |
| t_dummy.start(0.5); |
| t_dummy.timeout; |
| |
| //f_EPTF_LGenBase_setCPS(0, pl_newCps := 0.0); |
| //f_EPTF_LGenBase_setScenarioCPS(c_eGrpName, c_scNameWeighted, 0.0) |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| } // group ZeroCPSTest |
| |
| group CPSChangeCallback { |
| type component EPTF_LGenBase_CPSChangeCallback_CT extends EPTF_LGenBase_Test_CT{ |
| var boolean v_testCPSChangeCallback_TC := false; |
| var boolean v_testCPSChangeCallback_SC := false; |
| } |
| |
| function f_EPTF_LGenBase_Test_trafficCaseCPSChangedCallbackFn(in float pl_cps, in integer pl_tcIdx) runs on EPTF_LGenBase_CPSChangeCallback_CT { |
| v_testCPSChangeCallback_TC := true; |
| |
| var charstring vl_eGrpName; |
| var charstring vl_scName; |
| var charstring vl_tcName; |
| f_EPTF_LGenBase_trafficCaseIdNames(pl_tcIdx,vl_eGrpName,vl_scName,vl_tcName); |
| log(%definitionId&" TrafficCaseCPSChanged callback called with pl_cps: ", pl_cps, ", pl_tcIdx: ", pl_tcIdx, ", TC name: ", vl_eGrpName,".",vl_scName,".",vl_tcName); |
| } |
| |
| function f_EPTF_LGenBase_Test_scenarioCPSChangedCallbackFn(in float pl_cps, in integer pl_eGrpIdx, in integer pl_scIdx) runs on EPTF_LGenBase_CPSChangeCallback_CT { |
| v_testCPSChangeCallback_SC := true; |
| |
| var charstring vl_eGrpName; |
| var charstring vl_scName; |
| f_EPTF_LGenBase_scenarioIdNames(pl_eGrpIdx,pl_scIdx,vl_eGrpName,vl_scName); |
| log(%definitionId&" ScenarioCPSChanged callback called with pl_cps: ", pl_cps, ", pl_eGrpIdx: ", pl_eGrpIdx, ", pl_scIdx: ", pl_scIdx, ", TC name: ", vl_eGrpName,".",vl_scName); |
| } |
| |
| function f_EPTF_LGenBase_Test_CPSChangeCallback_checkCleanup() |
| runs on EPTF_LGenBase_CPSChangeCallback_CT{ |
| if(not v_testCPSChangeCallback_TC) { |
| log(%definitionId&" Error: CPSChange callback was not called for traffic case") |
| setverdict(fail); |
| } |
| else if(not v_testCPSChangeCallback_SC) { |
| log(%definitionId&" Error: CPSChange callback was not called for scenario") |
| setverdict(fail); |
| } |
| else { |
| log(%definitionId&": CPSChange callback was called for traffic case and scenario") |
| setverdict(pass) |
| } |
| } |
| |
| function f_EPTF_LGenBase_Test_CPSChangeCallback_init() |
| runs on EPTF_LGenBase_CPSChangeCallback_CT |
| { |
| const charstring c_eGrpName := "eg0" |
| const charstring c_scNameWeighted :="Scenario_Weighted" |
| const charstring c_tcName := "testTC" |
| f_EPTF_LGenBase_init("actionsPerCondition"); |
| v_testCPSChangeCallback_TC := false; |
| v_testCPSChangeCallback_SC := false; |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_LGenBase_Test_CPSChangeCallback_checkCleanup)); |
| |
| v_dummyInt := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := c_eGrpName, eType := "Entity_Tc_A", eCount := 5}) |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable({ |
| name := "stop", |
| fsmParams := { |
| {stateList := {"idle"}} |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{ |
| {c_EPTF_LGenBase_stepName_testFinished, omit} |
| }, omit, omit} |
| } |
| } |
| } |
| } |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareTcType2({ |
| name := "TC_Succ", |
| fsmName := "stop", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := "Scenario_Simple", |
| tcList := { |
| { |
| tcName := "TC_A0", |
| tcParamsList := { |
| {tcTypeName := "TC_Succ"}, |
| {target := {cpsToReach := 0.0}}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true} |
| } |
| } |
| }, |
| |
| scParamsList := {} |
| }) |
| |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg0", "Scenario_Simple"}, false) |
| |
| |
| f_EPTF_LGenBase_startTrafficCaseByIdx(0) |
| |
| var charstring vl_eGrpName, vl_scName, vl_tcName; |
| f_EPTF_LGenBase_trafficCaseIdNames(0, vl_eGrpName, vl_scName, vl_tcName) |
| |
| f_EPTF_LGenBase_registerCPSChangedCallback_TC( |
| vl_eGrpName,vl_scName,vl_tcName, |
| refers(f_EPTF_LGenBase_Test_trafficCaseCPSChangedCallbackFn) |
| ); |
| |
| //Weighted scenario |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { |
| name := c_scNameWeighted, |
| tcList := { |
| { tcName := "statTC0", |
| tcParamsList := { |
| {tcTypeName := "TC_Succ"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {trafficWeight := 0.5}} |
| } |
| }, |
| { tcName := c_tcName, |
| tcParamsList := { |
| {tcTypeName := "TC_Succ"}, |
| {enableEntitiesAtStart := true}, |
| {enabledAtStart := true}, |
| {target := {trafficWeight := 0.5}} |
| } |
| } |
| }, |
| scParamsList := { |
| {weightedScData := { |
| cpsToReach := 1111.0, |
| lockCPS := false, |
| deterministicMix := false, |
| scheduler := omit |
| } |
| }, |
| {enabled := true} |
| } |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({c_eGrpName, c_scNameWeighted},true) |
| |
| f_EPTF_LGenBase_registerCPSChangedCallback_SC( |
| c_eGrpName,c_scNameWeighted, |
| refers(f_EPTF_LGenBase_Test_scenarioCPSChangedCallbackFn) |
| ); |
| |
| } |
| |
| // purpose: test if the CPS change callback registered for TC and SC are called |
| testcase tc_EPTF_LGenBase_Test_CPSChangeCallback() |
| runs on EPTF_LGenBase_CPSChangeCallback_CT{ |
| const charstring c_eGrpName := "eg0" |
| const charstring c_scNameWeighted :="Scenario_Weighted" |
| |
| f_EPTF_LGenBase_Test_CPSChangeCallback_init(); |
| |
| |
| timer t_dummy; // to give time for TC setup |
| t_dummy.start(0.5); |
| t_dummy.timeout; |
| |
| f_EPTF_LGenBase_setCPS(0, pl_newCps := 10.0); |
| f_EPTF_LGenBase_setScenarioCPS(c_eGrpName, c_scNameWeighted, 0.0) |
| |
| t_dummy.start(0.6); |
| t_dummy.timeout; |
| |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| } // group CPSChangeCallback |
| |
| type component EPTF_LGenBase_TestDebugLight_CT extends EPTF_LGenBase_Test_CT{ |
| port PIPEasp_PT v_pipe_PCO; |
| var EPTF_CharstringList v_logLines := {}; |
| } |
| |
| modulepar charstring tsp_LGenBaseDebugLightLogFile := "@tcclab2-MTC.log" |
| modulepar float tsp_LGenBaseDebugLightPipeGuard := 3.0 |
| |
| function EPTF_LGenBase_TestDebugLight_logPreamble(in charstring pl_message) |
| runs on EPTF_LGenBase_TestDebugLight_CT |
| { |
| if(-1 != f_strstr(pl_message, "DebugLight:FSM")) { |
| v_logLines[sizeof(v_logLines)] := pl_message; |
| } |
| } |
| |
| testcase tc_EPTF_LGenBase_Test_debugLight() |
| runs on EPTF_LGenBase_TestDebugLight_CT{ |
| f_EPTF_LGenBase_init("Test_debugLight") |
| v_dummyInt := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1","input1"); |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 20}) |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable({ |
| name := "FSMNoDebug", |
| fsmParams := { |
| {stateList := {"idle"}} |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{ |
| {c_EPTF_LGenBase_stepName_recordEntityStart, omit} |
| }, omit, omit} |
| } |
| } |
| } |
| } |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "FSM2bDebug", |
| fsmParams := { |
| {stateList := {"idle","busy"}}, |
| {timerList := { |
| {"t1",0.5}, |
| {"t2",0.1} |
| }} |
| }, |
| table := { |
| extendedTable := { |
| { events2Listen := {events := {{ singleEvent := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}}}}, |
| cellRow := { statedCellRow := { |
| { inState := {state := "idle"}, |
| cell := {{ |
| {c_EPTF_LGenBase_stepName_recordEntityStart, {stepContextArgs := {1,3,2,4}}}, |
| {c_EPTF_LGenBase_stepName_timerStart, {timerName := "t1"}}, |
| {c_EPTF_LGenBase_stepName_timerStart, {timerName := "t2"}} |
| }, |
| omit, "busy"} |
| } |
| } |
| } |
| }, |
| { events2Listen := {events := {{ singleEvent := {c_EPTF_LGenBase_specialBName_timerTimeout,"t1",fsm}}}}, |
| cellRow := { statedCellRow := { |
| { inState := {state := "busy"}, |
| cell := {{ |
| {c_EPTF_LGenBase_stepName_trafficSuccess, omit} |
| }, |
| //Stay in "busy" state |
| omit, omit} |
| } |
| } |
| } |
| } |
| } |
| } |
| }) |
| |
| f_EPTF_Logging_registerPreambleFn(refers(EPTF_LGenBase_TestDebugLight_logPreamble)); |
| f_EPTF_LGenBase_setFsmDebugLight(f_EPTF_LGenBase_fsmNameIndex("FSM2bDebug"), true); |
| if(not f_EPTF_LGenBase_getFsmDebugLight(f_EPTF_LGenBase_fsmNameIndex("FSM2bDebug")) or |
| f_EPTF_LGenBase_getFsmDebugLight(f_EPTF_LGenBase_fsmNameIndex("FSMNoDebug"))) { |
| setverdict(fail); |
| } |
| |
| v_dummyInt := f_EPTF_LGenBase_declareTcType2({ |
| name := "TC_Succ", |
| fsmName := "FSMNoDebug", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareTcType2({ |
| name := "TC2bDebug", |
| fsmName := "FSM2bDebug", |
| entityType := "Entity_Tc_A", |
| customEntitySucc := "" |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3({ |
| name := "sc1", |
| tcList := { |
| { tcName := "TC_Succ", |
| tcParamsList := { |
| {enabledAtStart := false}, |
| {target := {cpsToReach := 0.0}} |
| } |
| }, |
| { tcName := "TC2bDebug", |
| tcParamsList := { |
| {enabledAtStart := false}, |
| {target := {cpsToReach := 0.0}} |
| } |
| } |
| }, |
| scParamsList := { |
| {trafficType := terminating} |
| } |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg0","sc1"}) |
| var EPTF_LGenBase_ReportedEventDescriptor vl_event := c_EPTF_LGenBase_emptyReportedEventDescriptor |
| vl_event.event.bIdx := c_EPTF_LGenBase_bIdx |
| vl_event.event.iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_startTC |
| vl_event.event.target.eIdx := 1 |
| vl_event.event.target.fsmCtxIdx := 0 |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| vl_event.event.target.fsmCtxIdx := 1 |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| timer t_wait |
| t_wait.start( 2.0 ) |
| t_wait.timeout |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| |
| //split |
| const EPTF_CharstringList c_line :={ |
| "DebugLight:FSM:FSM2bDebug:Entity#1#"""& |
| "\nReported event: ""LGenBase: Start_the_traffic_case!"""& |
| "\nBehavior ""EPTF_CLL_LGenBase"""& |
| "\nFSM: ""FSM2bDebug"""& |
| "\nEntity#1#"& |
| "\nCurrent state: ""idle"""& |
| "\nNext state: ""busy"""& |
| "\nExecuted test steps: {" & |
| " ""Step name: EPTF_CLL_LGenBase_StepFunctions.f_EPTF_LGenBase_step_recordEntityStart FSM context args: [1;3;2;4] Step args: []""," & |
| " ""Step name: EPTF_CLL_LGenBase_StepFunctions.f_EPTF_LGenBase_step_timerStart FSM context args: [0] Step args: []""," & |
| " ""Step name: EPTF_CLL_LGenBase_StepFunctions.f_EPTF_LGenBase_step_timerStart FSM context args: [1] Step args: []"""& |
| " }", |
| "DebugLight:FSM:FSM2bDebug:Entity#1#"""& |
| "\nThere is no listener to"& |
| "\nInput: ""Timeout of the FSM timer t2"""& |
| "\nBehavior: ""Special behavior for timeout reporting"""& |
| "\nFSM ""FSM2bDebug"""& |
| "\nin any state", |
| "DebugLight:FSM:FSM2bDebug:Entity#1#"""& |
| "\nReported event: ""Timeout of the FSM timer t1"""& |
| "\nBehavior ""Special behavior for timeout reporting"""& |
| "\nFSM: ""FSM2bDebug"""& |
| "\nEntity#1#"& |
| "\nCurrent state: ""busy"""& |
| "\nNext state: ""busy"""& |
| "\nExecuted test steps: { "& |
| """Step name: EPTF_CLL_LGenBase_StepFunctions.f_EPTF_LGenBase_step_trafficSuccess FSM context args: [] Step args: [0]"""& |
| " }", |
| "DebugLight:FSM:FSM2bDebug:Entity#1#"""& |
| "\nThere is no listener to"& |
| "\nInput: ""LGenBase: Start_the_traffic_case!"""& |
| "\nBehavior: ""EPTF_CLL_LGenBase"""& |
| "\nFSM ""FSM2bDebug"""& |
| "\nState ""busy""" |
| } |
| |
| //action("v_logLines: ",v_logLines) |
| if(sizeof(c_line)!= sizeof(v_logLines) and 0 < sizeof(v_logLines)){ |
| log("There are more lines: ",v_logLines) |
| setverdict(fail) |
| }else{ |
| if(0 < sizeof(v_logLines)){ |
| //Process the answer |
| for ( var integer vl_i := 0; vl_i < sizeof(c_line) ; vl_i := vl_i+1 ){ |
| var integer vl_pos := f_strstr(v_logLines[vl_i], "DebugLight:FSM") |
| if(substr(v_logLines[vl_i],vl_pos, lengthof(v_logLines[vl_i])-vl_pos) != c_line[vl_i]){ |
| log(match(substr(v_logLines[vl_i],vl_pos, lengthof(v_logLines[vl_i])-vl_pos),c_line[vl_i])) |
| setverdict(fail) |
| }else{ |
| setverdict(pass) |
| } |
| } |
| } |
| } |
| |
| f_EPTF_Logging_removePreambleFn(refers(EPTF_LGenBase_TestDebugLight_logPreamble)); |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| group functionByName{ |
| testcase tc_EPTF_LGenBase_Test_functionReferenceByName() |
| runs on EPTF_LGenBase_Test_CT{ |
| const charstring c_functionReferenceName := "nextStateCalcTestFn" |
| f_EPTF_LGenBase_init("Test_functionReferenceByName") |
| var integer vl_fnIdx := f_EPTF_LGenBase_declareFunction( |
| c_functionReferenceName, |
| {nextStateCalcFunction := refers(f_EPTF_LGenBase_Test_nextStateCalcTestFn)}) |
| if(vl_fnIdx != f_EPTF_LGenBase_functionNameIndex(c_functionReferenceName)){ |
| setverdict(fail,"Function name index not match.") |
| } |
| var EPTF_LGenBase_RegisteredFunctions vl_temp |
| if(not f_EPTF_LGenBase_functionReferenceByName(c_functionReferenceName,vl_temp)){ |
| setverdict(fail) |
| }else{ |
| if(vl_temp != {nextStateCalcFunction := refers(f_EPTF_LGenBase_Test_nextStateCalcTestFn)}){ |
| setverdict(fail) |
| }else{ |
| if(f_EPTF_LGenBase_functionReferenceByName("dummyFunctionNameNotExists",vl_temp)){ |
| setverdict(fail) |
| }else{ |
| setverdict(pass) |
| } |
| } |
| } |
| f_EPTF_Base_cleanup_CT(); |
| } |
| } |
| |
| //f_EPTF_LGenBase_stepArgs2IntList |
| group stepArgs2IntList{ |
| const charstring c_LGenBase_Test_varParamNoContentVarName := "varParamNoContentVarName" |
| const charstring c_LGenBase_Test_varParamNoContentStepName := "varParamNoContentStepName" |
| |
| function f_EPTF_LGenBase_step_varParamsNoContent(in EPTF_LGenBase_TestStepArgs pl_args) |
| runs on EPTF_LGenBase_Test_CT |
| { |
| //testing f_EPTF_LGenBase_getNameOfExpiredTimer |
| //the return value of the function should be "timer_2" |
| var integer vl_varId |
| var EPTF_Var_DirectContent vl_content |
| f_EPTF_LGenBase_fsmVarParamsFromStep(pl_args, vl_varId, vl_content) |
| if (not ischosen(vl_content.unknownVal)){ |
| log("The content should be unknownVal instead of ",vl_content) |
| setverdict ( fail); |
| } |
| var charstring vl_varName1 := f_EPTF_Var_getName(vl_varId) |
| var charstring vl_varName2 := f_EPTF_LGenBase_varNameOfFSMVar(1, 0, c_LGenBase_Test_varParamNoContentVarName) |
| if(vl_varName1 != vl_varName2){ |
| log(match(vl_varName1, vl_varName2)) |
| setverdict ( fail); |
| } |
| setverdict(pass); |
| } |
| |
| testcase tc_EPTF_LGenBase_Test_varParamsNoContent() |
| runs on EPTF_LGenBase_Test_CT{ |
| f_EPTF_LGenBase_init("Test_functionReferenceByName") |
| var integer |
| vl_bIdx := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| var integer |
| vl_iIdx := f_EPTF_LGenBase_declareFsmEvent("b1","input1"); |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 20}) |
| v_dummyInt := f_EPTF_LGenBase_declareStep("b1",{c_LGenBase_Test_varParamNoContentStepName, refers(f_EPTF_LGenBase_step_varParamsNoContent)}) |
| var integer |
| vl_tableIdx := f_EPTF_LGenBase_declareFSMTable({ |
| name := "FSMNoDebug", |
| fsmParams := { |
| {varList := |
| {{ |
| name := c_LGenBase_Test_varParamNoContentVarName, |
| initValue := {intVal := 9}, |
| scope := FSM |
| }} |
| }, |
| {stateList := {"idle"}} |
| }, |
| table := { |
| extendedTable := { |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","input1", fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "idle"}, |
| cell := { |
| {{c_LGenBase_Test_varParamNoContentStepName,{varParams := {c_LGenBase_Test_varParamNoContentVarName,omit}}}}, |
| omit,omit |
| } |
| } |
| }} |
| }} |
| } |
| }) |
| f_EPTF_LGenBase_activateFsm(1, vl_tableIdx, 0, -1) |
| var EPTF_LGenBase_ReportedEventDescriptor vl_event := c_EPTF_LGenBase_emptyReportedEventDescriptor |
| vl_event.event.bIdx := vl_bIdx |
| vl_event.event.iIdx := vl_iIdx |
| vl_event.event.target.eIdx := 1 |
| vl_event.event.target.fsmCtxIdx := 0 |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| f_EPTF_Base_cleanup_CT(); |
| } |
| } |
| |
| group negativeTCs{ |
| function buildErrorousFSM(in charstring pl_selfName) |
| runs on EPTF_LGenBase_CT{ |
| f_EPTF_LGenBase_init(pl_selfName); |
| |
| f_EPTF_Base_setNegativeTestMode(); |
| //This problem comes from the configuration (bad FSM), therefore it must throw |
| //error instead of assertion, according to the TitanSim coding guideline. |
| //f_EPTF_Base_setExpectedAssertMsg("f_EPTF_LGenBase_convertEvent: The declared b1.i3 event name is not valid in row \(1\) of FSM statFSM!"); |
| f_EPTF_Base_setExpectedErrorMsg("*b1.i3 event name is not valid in row \(1\) of FSM statFSM!*"); |
| |
| var integer |
| v_bIdx := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| var integer |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "i1") |
| var integer |
| v_iIdx := f_EPTF_LGenBase_declareFsmEvent("b1", "i2") |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg_base", eType := "Entity_Tc_A", eCount := 125}) |
| var integer |
| v_FSM := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "statFSM", |
| fsmParams := { |
| {stateList := {"idle"}} |
| ,{varList := { |
| {name := "vf_callCounter", initValue := {intVal := 0}, scope := FSM} |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := { bName := "b1", iName := "i1", eventType := entity }, |
| cellRow := { |
| //state==idle |
| {actionList := { |
| {stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarInc, contextArgs :={varParams := {"vf_callCounter",{intVal := 1}}}} |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| ,{eventToListen := { bName := "b1", iName := "i3", eventType := entity }, |
| cellRow := { |
| //state==idle |
| {actionList := { |
| {stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarInc, contextArgs :={varParams := {"vf_callCounter",{intVal := 1}}}} |
| }, |
| nextStateCalculation := omit, |
| nextState := omit |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm //XCAPget_DOT:} |
| ) |
| log("This will not be printed"); |
| |
| } |
| |
| // TR: HL24871 |
| testcase tc_fsm_dispatch_error() |
| //Negative test |
| runs on EPTF_LGenBase_CT{ |
| buildErrorousFSM("FSM_builder"); |
| setverdict(pass); |
| f_EPTF_Base_cleanup_CT() |
| } |
| } |
| |
| //CR_CT00016446 |
| group randomTimer{ |
| testcase tc_EPTF_LGenBase_Test_randomTimer() |
| runs on EPTF_LGenBase_Test_CT{ |
| const float c_minVal := 0.3, c_maxVal := 1.5, |
| c_minCheckVal := c_minVal *0.99, |
| c_maxCheckVal := c_maxVal *1.01 |
| const float c_minVal2 := 1.7, c_maxVal2 := 2.1, |
| c_minCheckVal2 := c_minVal2 *0.99, |
| c_maxCheckVal2 := c_maxVal2 *1.01 |
| f_EPTF_LGenBase_init("Test_randomTimer") |
| v_dummyInt := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| var integer |
| vl_FSM := f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "randomTimerFSM", |
| fsmParams := { |
| {stateList := {"idle"}}, |
| {randomTimerList := { |
| {name := "rndTimer", timeoutMin := c_minVal, timeoutMax := c_maxVal} |
| } |
| }, |
| { |
| statMeasWithParamsList := { |
| { |
| name := "chrono", |
| providerVarName := "", |
| targetVarName := "", |
| statMeasParams := { |
| statType := chrono |
| }, |
| scope := FSM |
| } |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := { c_EPTF_LGenBase_behavior, c_EPTF_LGenBase_inputName_testMgmt_startTC, fsm }, |
| cellRow := {{ |
| { |
| {c_EPTF_LGenBase_stepName_timerStart, {timerName := "rndTimer"}}, |
| {c_EPTF_LGenBase_stepName_fsmResetChrono,{statMeasName := "chrono"}}, |
| {c_EPTF_LGenBase_stepName_fsmStartChrono,{statMeasName := "chrono"}} |
| },omit,omit |
| } |
| } |
| }, |
| {eventToListen := {c_EPTF_LGenBase_specialBName_timerTimeout,"rndTimer",fsm}, |
| cellRow := { |
| {{ |
| {c_EPTF_LGenBase_stepName_fsmStopChrono,{statMeasName := "chrono"}}, |
| {c_EPTF_LGenBase_stepName_testFinished,omit} |
| },omit,omit |
| } |
| } |
| } |
| } |
| }//table |
| }//fsm //XCAPget_DOT:} |
| ) |
| v_dummyInt := f_EPTF_LGenBase_addGeneralEventListener( |
| c_EPTF_LGenBase_bIdx, |
| c_EPTF_LGenBase_inputIdx_testMgmt_testFinished, |
| refers(f_EPTF_LGenBase_Test_testFinishedListener), {}) |
| |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 20}) |
| //* |
| f_EPTF_LGenBase_activateFsm(1, vl_FSM, 0, -1) |
| /*/ |
| v_dummyInt := f_EPTF_LGenBase_declareTrafficCaseType({ |
| "TC1", |
| "randomTimerFSM", |
| "Entity_Tc_A", |
| {} |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { "SC1", |
| { |
| {"TC1",{ |
| {target := {cpsToReach := 0.0}} |
| } |
| } |
| }, |
| {} |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg0","SC1"},false) |
| //*/ |
| var EPTF_LGenBase_ReportedEventDescriptor vl_event := c_EPTF_LGenBase_emptyReportedEventDescriptor |
| vl_event.event.bIdx := c_EPTF_LGenBase_bIdx |
| vl_event.event.iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_startTC |
| vl_event.event.target.eIdx := 1 |
| vl_event.event.target.fsmCtxIdx := 0 |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| v_LGenBase_testFinished := false |
| f_EPTF_LGenBase_wait4TestFinished(25.0) |
| var integer vl_chronoStatId := f_EPTF_LGenBase_fsmStatMeasIdOfFSM(1, 0, "chrono") |
| var EPTF_Var_DirectContent vl_content |
| f_EPTF_StatMeasure_stat2Var(vl_chronoStatId, vl_content) |
| var float vl_timerTimeOut := vl_content.floatVal |
| |
| if(vl_timerTimeOut<c_minCheckVal or vl_timerTimeOut > c_maxCheckVal){ |
| setverdict(fail, "First timeout value is: ",vl_timerTimeOut,", c_minVal: ",c_minVal, " ,c_maxVal: ",c_maxVal) |
| } |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| f_EPTF_LGenBase_wait4TestFinished(25.0) |
| f_EPTF_StatMeasure_stat2Var(vl_chronoStatId, vl_content) |
| if(vl_content.floatVal<c_minCheckVal or vl_content.floatVal > c_maxCheckVal){ |
| setverdict(fail, "First timeout value is: ",vl_content.floatVal,", c_minVal: ",c_minVal, " ,c_maxVal: ",c_maxVal) |
| } |
| if(-0.01 > vl_content.floatVal - vl_timerTimeOut and |
| 0.01 < vl_content.floatVal - vl_timerTimeOut){ |
| setverdict(fail, "The timer timeouts (",vl_content.floatVal," and ",vl_timerTimeOut,") are probably the same.") |
| } |
| f_EPTF_LGenBase_setDurations4TimerAtFsmCtxByName(1, 0, "rndTimer", c_minVal2, c_maxVal2) |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| f_EPTF_LGenBase_wait4TestFinished(25.0) |
| f_EPTF_StatMeasure_stat2Var(vl_chronoStatId, vl_content) |
| if(vl_content.floatVal<c_minCheckVal2 or vl_content.floatVal > c_maxCheckVal2){ |
| setverdict(fail, "Changed timeout value is: ",vl_content.floatVal,", c_minVal2: ",c_minVal2, " ,c_maxVal2: ",c_maxVal2) |
| } |
| setverdict(pass) |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| function f_EPTF_LGenBase_Test_randomTimerParams( |
| in float pl_minVal := 1.7, |
| in float pl_maxVal := 3.14, |
| in charstring pl_rndTimerName := "rndTimer" |
| ) |
| runs on EPTF_LGenBase_CT{ |
| f_EPTF_LGenBase_declareFSMTable( |
| { |
| name := "randomTimerFSM", |
| fsmParams := { |
| {stateList := {"idle"}}, |
| {timerList := {{"t1", 3.7}}}, |
| {randomTimerList := { |
| {pl_rndTimerName, pl_minVal, pl_maxVal} |
| } |
| } |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := { c_EPTF_LGenBase_behavior, c_EPTF_LGenBase_inputName_testMgmt_startTC, fsm }, |
| cellRow := {{omit,omit,omit}} |
| } |
| } |
| }//table |
| }//fsm //XCAPget_DOT:} |
| ) |
| } |
| testcase tc_EPTF_LGenBase_Test_randomTimerNames() |
| runs on EPTF_LGenBase_CT{ |
| f_EPTF_LGenBase_init("Test_randomTimerNames") |
| f_EPTF_Base_setNegativeTestMode() |
| f_EPTF_Base_setExpectedAssertMsg("f_EPTF_LGenBase_processTimerDeclarations: The FSM timer t1 is already defined in table randomTimerFSM!") |
| f_EPTF_LGenBase_Test_randomTimerParams(pl_rndTimerName := "t1") |
| f_EPTF_Base_cleanup_CT() |
| } |
| testcase tc_EPTF_LGenBase_Test_randomTimerInvalidMinValue() |
| runs on EPTF_LGenBase_Test_CT{ |
| f_EPTF_LGenBase_init("Test_randomTimerInvalidMinValue") |
| f_EPTF_Base_setNegativeTestMode() |
| f_EPTF_Base_setExpectedAssertMsg("f_EPTF_LGenBase_processTimerDeclarations: The minimal timeout value of FSM timer rndTimer of table randomTimerFSM must be a positive value instead of -5.300000") |
| f_EPTF_LGenBase_Test_randomTimerParams(pl_minVal := -5.3) |
| f_EPTF_Base_cleanup_CT() |
| } |
| testcase tc_EPTF_LGenBase_Test_randomTimerInvalidMaxValue() |
| runs on EPTF_LGenBase_CT{ |
| f_EPTF_LGenBase_init("Test_randomTimerInvalidMaxValue") |
| f_EPTF_Base_setNegativeTestMode() |
| f_EPTF_Base_setExpectedAssertMsg("f_EPTF_LGenBase_processTimerDeclarations: The maximal timeout value of FSM timer rndTimer of table randomTimerFSM must be a positive value instead of -5.300000") |
| f_EPTF_LGenBase_Test_randomTimerParams(pl_maxVal := -5.3) |
| f_EPTF_Base_cleanup_CT() |
| } |
| testcase tc_EPTF_LGenBase_Test_randomTimerInvalidValues() |
| runs on EPTF_LGenBase_CT{ |
| f_EPTF_LGenBase_init("Test_randomTimerInvalidValues") |
| f_EPTF_Base_setNegativeTestMode() |
| f_EPTF_Base_setExpectedAssertMsg("f_EPTF_LGenBase_processTimerDeclarations: The maximal timeout value \(2.300000\) of FSM timer rndTimer of table randomTimerFSM must be greater than the minimal timeout value: 5.300000") |
| f_EPTF_LGenBase_Test_randomTimerParams(pl_minVal := 5.3, pl_maxVal := 2.3) |
| f_EPTF_Base_cleanup_CT() |
| } |
| } |
| |
| //HL48155 |
| testcase tc_EPTF_LGenBase_Test_setCPSRunning() |
| runs on EPTF_LGenBase_Test_CT{ |
| f_EPTF_LGenBase_init("setCPSRunning") |
| v_dummyInt := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| f_EPTF_LGenBase_declareFSMTable({ |
| name := "setCPSRunning", |
| fsmParams := { |
| {stateList := {"idle"}}, |
| {varList:= { |
| {"counter",{intVal := 0}, TC } |
| }} |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{ |
| {c_EPTF_LGenBase_stepName_fsmVarInc,{varParams := {"counter",{intVal := 1}}}}, |
| {c_EPTF_LGenBase_stepName_trafficSuccess,omit} |
| }, omit, omit} |
| } |
| } |
| } |
| } |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 20}) |
| v_dummyInt := f_EPTF_LGenBase_declareTrafficCaseType({ |
| "TC1", |
| "setCPSRunning", |
| "Entity_Tc_A", |
| {} |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { "SC1", |
| { |
| {"TC1",{ |
| {target := {cpsToReach := 0.01}}, |
| {enabledAtStart := true}, |
| {enableEntitiesAtStart := true} |
| } |
| }, |
| {"TC2",{ |
| {target := {cpsToReach := 0.0}}, |
| {tcTypeName := "TC1"}, |
| {enabledAtStart := true}, |
| {enableEntitiesAtStart := true} |
| } |
| } |
| }, |
| { |
| {enabled := true} |
| } |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg0","SC1"},true) |
| timer t1 |
| t1.start( 0.1 ) |
| t1.timeout |
| f_EPTF_LGenBase_setCPS(0, 100.0) |
| f_EPTF_LGenBase_setCPS(1, 100.0) |
| t1.start( 1.1 ) |
| t1.timeout |
| f_EPTF_LGenBase_stopScenarioByIdx(0,0) |
| var charstring vl_varName := f_EPTF_LGenBase_varNameOfTCVar(0, "counter") |
| var integer vl_varId := f_EPTF_Var_getId(vl_varName) |
| var EPTF_Var_DirectContent vl_content |
| f_EPTF_Var_getContent(vl_varId, vl_content) |
| //action(vl_content.intVal) |
| if(1 < vl_content.intVal){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail,"The traffic case#0 not started.") |
| } |
| vl_varName := f_EPTF_LGenBase_varNameOfTCVar(1, "counter") |
| vl_varId := f_EPTF_Var_getId(vl_varName) |
| f_EPTF_Var_getContent(vl_varId, vl_content) |
| //action(vl_content.intVal) |
| if(1 < vl_content.intVal){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail,"The traffic case#1 not started.") |
| } |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| //f_EPTF_LGenBase_getTCStartDelayByName |
| testcase tc_EPTF_LGenBase_Test_getTCStartDelay() |
| runs on EPTF_LGenBase_Test_CT{ |
| const float c_delay1 := 9.7, c_delay2 := 3.14 |
| f_EPTF_LGenBase_init("getTCStartDelay") |
| v_dummyInt := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| f_EPTF_LGenBase_declareFSMTable({ |
| name := "getTCStartDelay", |
| fsmParams := { |
| {stateList := {"idle"}} |
| }, |
| table := { |
| classicTable := { |
| {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm}, |
| cellRow := { |
| {{{c_EPTF_LGenBase_stepName_trafficSuccess,omit}}, omit, omit} |
| } |
| } |
| } |
| } |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("Entity_Tc_A", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({name := "eg0", eType := "Entity_Tc_A", eCount := 20}) |
| v_dummyInt := f_EPTF_LGenBase_declareTrafficCaseType({ |
| "TC1", |
| "getTCStartDelay", |
| "Entity_Tc_A", |
| {} |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3( |
| { "SC1", |
| { |
| {"TC1",{ |
| {target := {cpsToReach := 0.01}}, |
| {enabledAtStart := true}, |
| {startDelay := c_delay1}, |
| {enableEntitiesAtStart := false} |
| } |
| }, |
| {"TC2",{ |
| {target := {cpsToReach := 0.0}}, |
| {tcTypeName := "TC1"}, |
| {startDelay := c_delay2}, |
| {enabledAtStart := true}, |
| {enableEntitiesAtStart := true} |
| } |
| } |
| }, |
| { |
| {enabled := true} |
| } |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg0","SC1"},false) |
| var float vl_delay |
| var boolean vl_ret := |
| f_EPTF_LGenBase_getTCStartDelayByName("eg0","SC1","TC1",vl_delay) |
| if(vl_ret and c_delay1 == vl_delay){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail) |
| } |
| vl_ret :=f_EPTF_LGenBase_getTCStartDelayByName("eg0","SC1","TC2",vl_delay) |
| if(vl_ret and c_delay2 == vl_delay){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail) |
| } |
| vl_ret :=f_EPTF_LGenBase_getTCStartDelayByIdx(1,vl_delay) |
| if(vl_ret and c_delay2 == vl_delay){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail) |
| } |
| vl_ret :=f_EPTF_LGenBase_getTCStartDelayByIdx(10,vl_delay) |
| if(not vl_ret){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail) |
| } |
| vl_ret :=f_EPTF_LGenBase_getTCStartDelayByIdx(-1,vl_delay) |
| if(not vl_ret){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail) |
| } |
| vl_ret :=f_EPTF_LGenBase_getTCStartDelayByName("eg0","SC10","TC2",vl_delay) |
| if(not vl_ret){ |
| setverdict(pass) |
| }else{ |
| setverdict(fail) |
| } |
| f_EPTF_Base_cleanup_CT() |
| } |
| |
| group HL47633{ |
| |
| const EPTF_Var_DirectContent c_EPTF_LGenBase_Test_statParamValue := {charstringVal := "statParamValue"} |
| |
| function f_EPTF_LGenBase_Test_checkStatParamsOmit( |
| in EPTF_LGenBase_TestStepArgs pl_ptr |
| ) runs on EPTF_LGenBase_CT{ |
| var integer vl_statId |
| var EPTF_Var_DirectContent vl_param |
| f_EPTF_LGenBase_fsmStatMeasParamsFromStep(pl_ptr, vl_statId, vl_param) |
| if(match(vl_param, {unknownVal := {omit}})){ |
| setverdict(pass) |
| }else{ |
| log("The statistic param value doesn't match with the given one") |
| log(match(vl_param, {unknownVal := {omit}})) |
| setverdict(fail,match(vl_param, {unknownVal := {omit}})) |
| } |
| } |
| |
| function f_EPTF_LGenBase_Test_checkStatParamsValue( |
| in EPTF_LGenBase_TestStepArgs pl_ptr |
| ) runs on EPTF_LGenBase_CT{ |
| var integer vl_statId |
| var EPTF_Var_DirectContent vl_param |
| f_EPTF_LGenBase_fsmStatMeasParamsFromStep(pl_ptr, vl_statId, vl_param) |
| if(match(vl_param, c_EPTF_LGenBase_Test_statParamValue)){ |
| setverdict(pass) |
| }else{ |
| log("The statistic param value doesn't match with the given one") |
| log(match(vl_param, c_EPTF_LGenBase_Test_statParamValue)) |
| setverdict(fail,match(vl_param, c_EPTF_LGenBase_Test_statParamValue)) |
| } |
| } |
| |
| function f_EPTF_LGenBase_Test_checkVarParamsOmit( |
| in EPTF_LGenBase_TestStepArgs pl_ptr |
| ) runs on EPTF_LGenBase_CT{ |
| var integer vl_statId |
| var EPTF_Var_DirectContent vl_param |
| f_EPTF_LGenBase_fsmVarParamsFromStep(pl_ptr, vl_statId, vl_param) |
| if(match(vl_param, {unknownVal := {omit}})){ |
| setverdict(pass) |
| }else{ |
| log("The statistic param value doesn't match with the given one") |
| log(match(vl_param, {unknownVal := {omit}})) |
| setverdict(fail,match(vl_param, {unknownVal := {omit}})) |
| } |
| } |
| |
| function f_EPTF_LGenBase_Test_checkVarParamsValue( |
| in EPTF_LGenBase_TestStepArgs pl_ptr |
| ) runs on EPTF_LGenBase_CT{ |
| var integer vl_statId |
| var EPTF_Var_DirectContent vl_param |
| f_EPTF_LGenBase_fsmVarParamsFromStep(pl_ptr, vl_statId, vl_param) |
| if(match(vl_param, c_EPTF_LGenBase_Test_statParamValue)){ |
| setverdict(pass) |
| }else{ |
| log("The statistic param value doesn't match with the given one") |
| log(match(vl_param, c_EPTF_LGenBase_Test_statParamValue)) |
| setverdict(fail,match(vl_param, c_EPTF_LGenBase_Test_statParamValue)) |
| } |
| } |
| const charstring c_LGenBase_Test_varAndStatParamsFSMName := "varAndStatParams" |
| const EPTF_LGenBase_FsmTableDeclarator c_LGenBase_Test_varAndStatParamsFSM := { |
| name := c_LGenBase_Test_varAndStatParamsFSMName, |
| fsmParams := |
| { |
| {varList := |
| {{ |
| name := "var1", |
| initValue := {intVal := 9}, |
| scope := FSM |
| }, |
| { |
| name := "var2", |
| initValue := {intVal := 9}, |
| scope := TC |
| }} |
| }, |
| {statMeasStatList := { |
| {"chrono1","",chrono,FSM}, |
| {"chrono2","",chrono,TC} |
| }}, |
| {stateList := {"idle", "busy","third"}} |
| }, |
| table := { |
| extendedTable := { |
| { |
| events2Listen := {events := { |
| { singleEvent := {"b1","event", fsm} } |
| }}, |
| cellRow := { statedCellRow := { |
| { |
| inState := {state := "idle"}, |
| cell := { |
| { |
| {"checkStatParamsOmit",{statMeasParams := {"chrono1",omit}}}, |
| {"checkVarParamsOmit",{varParams := {"var1",omit}}}, |
| {"checkStatParamsValue",{statMeasParams := {"chrono1",c_EPTF_LGenBase_Test_statParamValue}}}, |
| {"checkVarParamsValue",{varParams := {"var1",c_EPTF_LGenBase_Test_statParamValue}}}, |
| {"checkStatParamsOmit",{statMeasParams := {"chrono2",omit}}}, |
| {"checkVarParamsOmit",{varParams := {"var2",omit}}}, |
| {"checkStatParamsValue",{statMeasParams := {"chrono2",c_EPTF_LGenBase_Test_statParamValue}}}, |
| {"checkVarParamsValue",{varParams := {"var2",c_EPTF_LGenBase_Test_statParamValue}}} |
| },omit,omit} |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| function f_EPTF_LGenBase_Test_varAndStatParamsInit(in charstring pl_name) |
| runs on EPTF_LGenBase_Test_CT |
| return integer{ |
| f_EPTF_LGenBase_init(pl_name); |
| const integer c_entities := 6 |
| var integer v_behav := f_EPTF_LGenBase_declareBehaviorType("b1", -1, null, null, null); |
| v_dummyInt := f_EPTF_LGenBase_declareEntityType("et1", {"b1"}); |
| v_dummyInt := f_EPTF_LGenBase_createEntityGroup({"eg1", "et1", c_entities}) |
| v_dummyInt := f_EPTF_LGenBase_declareFsmEvent("b1", "event") |
| v_dummyInt := f_EPTF_LGenBase_declareFunction( |
| "checkStatParamsOmit", |
| {testStepFunction := refers(f_EPTF_LGenBase_Test_checkStatParamsOmit)}) |
| v_dummyInt := f_EPTF_LGenBase_declareFunction( |
| "checkStatParamsValue", |
| {testStepFunction := refers(f_EPTF_LGenBase_Test_checkStatParamsValue)}) |
| v_dummyInt := f_EPTF_LGenBase_declareFunction( |
| "checkVarParamsOmit", |
| {testStepFunction := refers(f_EPTF_LGenBase_Test_checkVarParamsOmit)}) |
| v_dummyInt := f_EPTF_LGenBase_declareFunction( |
| "checkVarParamsValue", |
| {testStepFunction := refers(f_EPTF_LGenBase_Test_checkVarParamsValue)}) |
| v_dummyInt := f_EPTF_LGenBase_declareFSMTable(c_LGenBase_Test_varAndStatParamsFSM) |
| return v_behav |
| } |
| |
| testcase tc_EPTF_LGenBase_Test_varAndStatParams() |
| runs on EPTF_LGenBase_Test_CT{ |
| var integer v_behav := f_EPTF_LGenBase_Test_varAndStatParamsInit("varAndStatParams") |
| v_dummyInt := f_EPTF_LGenBase_declareTcType2({ |
| name := "TC1", |
| fsmName := "varAndStatParams", |
| entityType := "et1", |
| customEntitySucc := "" |
| }) |
| v_dummyInt := f_EPTF_LGenBase_declareScenarioType3({ |
| name := "sc1", |
| tcList := { |
| { tcName := "TC1", |
| tcParamsList := { |
| {enabledAtStart := false}, |
| {target := {cpsToReach := 0.0}} |
| } |
| } |
| }, |
| scParamsList := { |
| } |
| }) |
| f_EPTF_LGenBase_createScenario2EntityGroup({"eg1","sc1"},false) |
| var EPTF_LGenBase_ReportedEventDescriptor vl_event := c_EPTF_LGenBase_emptyReportedEventDescriptor |
| vl_event.event.bIdx := v_behav |
| vl_event.event.iIdx := 0 |
| vl_event.event.target.eIdx := 1 |
| vl_event.event.target.fsmCtxIdx := 0 |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| f_EPTF_Base_cleanup_CT() |
| } |
| } |
| //HL74477 |
| testcase tc_EPTF_LGenBase_Test_varAndStatParamsNoTC() |
| runs on EPTF_LGenBase_Test_CT{ |
| f_EPTF_Base_init_CT("varAndStatParamsNoTC") |
| f_EPTF_Base_setExpectedAssertMsg("*There is no traffic case*varAndStatParams*") |
| var integer v_behav := f_EPTF_LGenBase_Test_varAndStatParamsInit("varAndStatParamsNoTC") |
| f_EPTF_LGenBase_activateFsm(1, 0, 0, -1) |
| var EPTF_LGenBase_ReportedEventDescriptor vl_event := c_EPTF_LGenBase_emptyReportedEventDescriptor |
| vl_event.event.bIdx := v_behav |
| vl_event.event.iIdx := 0 |
| vl_event.event.target.eIdx := 1 |
| vl_event.event.target.fsmCtxIdx := 0 |
| f_EPTF_LGenBase_dispatchEvent(vl_event) |
| f_EPTF_Base_cleanup_CT() |
| } |
| control{ |
| execute(tc_dispatcEntityEvent4TC()) |
| execute(tc_dispatcEntityEvent()) |
| execute(tc_testFSMs()) |
| execute(tc_lastCPSIs0()) |
| //execute(tc_fsmDeclCompare( )) |
| execute(tc_fsmCancelAllTimers()) |
| execute(tc_EPTF_LGenBase_Test_declareFSMTables()) |
| execute(tc_EPTF_LGenBase_Test_FsmGetFunctions()) |
| execute(tc_EPTF_LGenBase_Test_startDelay_cps_change_R4()) |
| execute(tc_EPTF_LGenBase_Test_startDelay_start_with_zero_cps_R4()) |
| execute(tc_EPTF_LGenBase_Test_startDelay_set_zero_cps_R4()) |
| execute(tc_EPTF_LGenBase_Test_startDelay_expired_R4()) |
| execute(tc_EPTF_LGenBase_Test_startDelay_pause_R4()); |
| execute(tc_EPTF_LGenBase_Test_nextStateParams()) |
| execute(tc_EPTF_LGenBase_Test_FsmStateGetFunctions()); |
| execute(tc_EPTF_LGenBase_Test_NameOfExpiredTimer()) |
| execute(tc_EPTF_LGenBase_Test_NameOfExpiredTimer_noTimer()); |
| execute(tc_EPTF_LGenBase_Test_ZeroCPSTest()); |
| execute(tc_EPTF_LGenBase_Test_CPSChangeCallback()); |
| execute(tc_EPTF_LGenBase_Test_functionReferenceByName()); |
| execute(tc_EPTF_LGenBase_Test_varParamsNoContent()); //HL42569 |
| execute(tc_EPTF_LGenBase_Test_debugLight()); |
| execute(tc_fsm_dispatch_error()) |
| execute(tc_EPTF_LGenBase_Test_randomTimer()) //CR_CT00016446 |
| execute(tc_EPTF_LGenBase_Test_randomTimerNames()) |
| execute(tc_EPTF_LGenBase_Test_randomTimerInvalidMinValue()) |
| execute(tc_EPTF_LGenBase_Test_randomTimerInvalidMaxValue()) |
| execute(tc_EPTF_LGenBase_Test_randomTimerInvalidValues()) |
| execute(tc_EPTF_LGenBase_Test_setCPSRunning()) |
| execute(tc_EPTF_LGenBase_Test_getTCStartDelay()) |
| execute(tc_EPTF_LGenBase_Test_varAndStatParamsNoTC()) |
| execute(tc_EPTF_LGenBase_Test_varAndStatParams()) |
| } |
| } // end of module |
