blob: b0fe41c832d13ff772ed4399e3f4914411afdd1d [file] [log] [blame]
///////////////////////////////////////////////////////////////////////////////
// //
// Copyright (c) 2000-2018 Ericsson Telecom AB //
// //
// All rights reserved. This program and the accompanying materials //
// are made available under the terms of the Eclipse Public License v2.0 //
// which accompanies this distribution, and is available at //
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html //
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//
// Purpose:
// This module provides functions for testing functionalities and bugfixes
// after version R14 of LGenBase
//
// Module depends on:
// -
//
// Current Owner:
// Janos Zoltan Svaner (EJNOSVN)
//
// Last Review Date:
// -
//
///////////////////////////////////////////////////////////////
module EPTF_LGenBase_Test_Testcases_Latest
// [.objid{ itu_t(0) identified_organization(4) etsi(0)
// identified_organization(127) ericsson(5) testing(0)
// <put further nodes here if needed>}]
{
import from EPTF_LGenBase_Test_Definitions all;
import from EPTF_LGenBase_Test_Functions all;
import from EPTF_CLL_LGenBase_Definitions all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_Common_Functions all;
import from EPTF_CLL_Common_Definitions all;
import from EPTF_CLL_ILog_Functions all;
import from EPTF_CLL_Logging_Functions all;
import from EPTF_CLL_LGenBase_ILog_Functions all;
import from EPTF_CLL_LGenBase_Functions all;
import from EPTF_CLL_LGenBase_ConfigFunctions all;
import from EPTF_CLL_LGenBase_ConfigDefinitions all;
import from EPTF_CLL_LGenBase_EventHandlingFunctions all;
import from EPTF_CLL_LGenBase_TrafficFunctions all;
import from EPTF_CLL_LGenBase_TemplateDefinitions all;
import from EPTF_CLL_LGenBase_TemplateFunctions all;
import from EPTF_CLL_LGenBase_StepFunctions all;
import from PIPEasp_PortType all;
import from PIPEasp_Types all;
modulepar
{
charstring tsp_dummyTemplatePathArithmetic := "../dummy_templ_arith.txt";
charstring tsp_dummyTemplatePathArithmetic_dos := "./dummy_templ_arith_dos.txt";
}
group LGenBase_DataSource_tests{
///////////////////////////////////////////////////////////
// TesScase: tc_LGenBase_DS_Neg_WrongConditionIsScPresent1
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: conditionIsScPresent
// Params: too few params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongConditionIsScPresent1() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_conditionIsScPresent,
{});
}
///////////////////////////////////////////////////////////
// TesScase: tc_LGenBase_DS_Neg_WrongConditionIsScPresent2
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: conditionIsScPresent
// Params: too few params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongConditionIsScPresent2() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_conditionIsScPresent,
{{c_LGenBase_paramNameEntityGroup, "eg1"}});
}
///////////////////////////////////////////////////////////
// TesScase: tc_LGenBase_DS_Neg_WrongConditionIsScPresent3
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: conditionIsScPresent
// Params: too many params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongConditionIsScPresent3() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_conditionIsScPresent,
{{c_LGenBase_paramNameEntityGroup, "eg1"},{c_LGenBase_paramNameScenario, "eg2"},{c_LGenBase_paramNameEntityGroup, "eg3"}});
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_DS_Neg_WrongConditionIsTcPresent1
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: conditionIsTcPresent
// Params: too few params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongConditionIsTcPresent1() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_conditionIsTcPresent,
{});
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_DS_Neg_WrongConditionIsTcPresent2
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: conditionIsTcPresent
// Params: too few params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongConditionIsTcPresent2() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_conditionIsTcPresent,
{{c_LGenBase_paramNameEntityGroup, "eg1"}});
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_DS_Neg_WrongConditionIsTcPresent3
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: conditionIsTcPresent
// Params: too many params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongConditionIsTcPresent3() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_conditionIsTcPresent,
{{c_LGenBase_paramNameEntityGroup, "eg1"},{c_LGenBase_paramNameScenario, "eg2"},{c_LGenBase_paramNameEntityGroup, "eg3"}, {c_LGenBase_paramNameEntityGroup, "eg4"}});
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_DS_Neg_WrongdataElementTcEnabledAtStartup1
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: dataElementTcEnabledAtStartup
// Params: too few params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongdataElementTcEnabledAtStartup1() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_dataElementTcEnabledAtStartup,
{});
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_DS_Neg_WrongdataElementTcEnabledAtStartup2
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: dataElementTcEnabledAtStartup
// Params: too few params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongdataElementTcEnabledAtStartup2() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_dataElementTcEnabledAtStartup,
{{c_LGenBase_paramNameEntityGroup, "eg1"}});
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_DS_Neg_WrongdataElementTcEnabledAtStartup3
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: dataElementTcEnabledAtStartup
// Params: too many params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongdataElementTcEnabledAtStartup3() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_dataElementTcEnabledAtStartup,
{{c_LGenBase_paramNameEntityGroup, "eg1"},{c_LGenBase_paramNameScenario, "eg2"},{c_LGenBase_paramNameEntityGroup, "eg3"}, {c_LGenBase_paramNameEntityGroup, "eg4"}});
}
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_ILog_tests
//
// Purpose: Test of the EPTF_CLL_LGenBase_ILog CLL functions.
//
// Action: The testcase .
//
// Expected Result: pass verdict. The test result is pass if all function operates without any error.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_ILog_tests() runs on EPTF_LGenBase_Test_CT {
// Init
// ---------------------------------------------------------------------------------------------------------
f_EPTF_LGenBase_init(c_ILog_testName);
// Just Magic 8>
// BehaviorType
v_ILog_behavOK := f_EPTF_LGenBase_declareBehaviorType(c_ILog_behavName, -1, null, null, null);
// FSM event
v_ILog_action := f_EPTF_LGenBase_declareFsmEvent(c_ILog_behavName, c_ILog_action);
// Entity
v_dummyInt := f_EPTF_LGenBase_declareEntityType(c_ILog_entityType, {c_ILog_behavName});
v_dummyInt := f_EPTF_LGenBase_createEntityGroup({c_ILog_entityGroup, c_ILog_entityType, 2});
// FSM
var integer vl_tIdx := f_EPTF_LGenBase_declareCompactFsmTable({
name := "iLogTestFsm",
// [0]
stateList := {"idle"},
timerList := {},
table := {
{eventToListen := {v_ILog_behavOK,v_ILog_action,fsm},
cellRow := {
//state[0]==idle
{{{refers(f_EPTF_ILog_Test_msgStep),{}}}, omit,0}
}
}
}
}
);
v_dummyInt := f_EPTF_LGenBase_activateFsm(pl_eIdx:= c_ILog_entityIdx1, pl_tIdx:= vl_tIdx, pl_sIdx:=0, pl_tcIdx:= -1)
v_dummyInt := f_EPTF_LGenBase_activateFsm(pl_eIdx:= c_ILog_entityIdx2, pl_tIdx:= vl_tIdx, pl_sIdx:=0, pl_tcIdx:= -1)
// ILog log DB:
var EPTF_LGenBase_TestStepArgs vl_testStepArgs1;
vl_testStepArgs1.eIdx := c_ILog_entityIdx1;
vl_testStepArgs1.refContext.fCtxIdx := vl_tIdx;
var EPTF_LGenBase_TestStepArgs vl_testStepArgs2;
vl_testStepArgs2.eIdx := c_ILog_entityIdx2;
vl_testStepArgs2.refContext.fCtxIdx := vl_tIdx;
// reset DB
f_EPTF_ILog_Test_resetDB();
// reset Log
f_EPTF_ILog_Test_resetLog();
// Calls <f_EPTF_ILogBase_register_DB>.
v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1] := f_EPTF_ILog_register_DB(refers(f_EPTF_ILog_Test_logItem), {c_ILog_entityIdx1});
v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx2] := f_EPTF_ILog_register_DB(refers(f_EPTF_ILog_Test_logItem), {c_ILog_entityIdx2});
// [1]: new chain add one element and log it with logFailed
// ---------------------------------------------------------------------------------------------------------
// This function creates a new chains or reuses an existing free chains for short and detailed chains.
// Sets the elements of the application data assigned to the FSM context.
action("f_EPTF_LGenBase_ILog_newChains->");
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_ILog_entityIdx1, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_first_detailed), pl_paramDetailed := {c_ILog_entityIdx1, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_first_short), pl_paramShort := {c_ILog_entityIdx1, vl_tIdx});
// getcheck
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, 1);
// Add element(s) short and or detailed chain Id(s) to the chains that are given in the input integer list than disable short log.
action("f_EPTF_LGenBase_ILog_addToChains->");
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, 0); // addToILog[0, 0] => detailed
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, 1);
// logFailed STEP
// The function creates the log from the items of the short and detailed chain.
action("f_EPTF_LGenBase_ILog_step_logFailed->");
f_EPTF_LGenBase_ILog_step_logFailed(vl_testStepArgs1);
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, -1);
// GET LOG STR
var charstring vl_logStr0 := f_EPTF_ILog_Test_getLogStr(c_ILog_entityIdx1);
const charstring cl_loxExpected0 := "<<[FIRST:short] ILogHeader: 1 - Short Chain - 0>>"&
"<<[FIRST:detailed] ILogHeader: 2 - Detailed Chain - 0>>"&
"{EPTF_ILog_Test: Event in chain#2 - 1 [0]: Detailed Chain ({ 0 }): addToILog[0, 0]}";
action("GET LOG STR[0]:", vl_logStr0);
if(match ( vl_logStr0, cl_loxExpected0 ) == false) {
setverdict(fail, "Log[0] not mach: " & log2str(match ( vl_logStr0, cl_loxExpected0 )));
}
action("GET LOG STR:", f_EPTF_ILog_Test_getLogStr(c_ILog_entityIdx1));
// reset DB & Log
f_EPTF_ILog_Test_resetDB();
f_EPTF_ILog_Test_resetLog();
// [2]: one add to chain without new chain => warning and logSuccess
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_LGenBase_ILog_addToChains->");
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, c_ILog_entityIdx1);
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, -1);
// [3] log success without valid chain
// ---------------------------------------------------------------------------------------------------------
// logSuccess STEP
// The function creates the log from the items of the short chain and deletes it from the detailed chain.
action("f_EPTF_LGenBase_ILog_step_logSuccess->");
f_EPTF_LGenBase_ILog_step_logSuccess(vl_testStepArgs1);
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, -1);
// GET LOG STR
action(f_EPTF_ILog_Test_getLogStr(c_ILog_entityIdx1));
// [4] delete log without valid chain
// ---------------------------------------------------------------------------------------------------------
// deleteLog STEP
// The function deletes the log from the items of the short and detailed chain.
action("f_EPTF_LGenBase_ILog_step_deleteLog->");
f_EPTF_LGenBase_ILog_step_deleteLog(vl_testStepArgs1);
action("GETERRORMSG:", f_EPTF_Common_getErrorMsg());
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, -1);
// [5] shortlog next without valid chain
// ---------------------------------------------------------------------------------------------------------
// shortLogNext STEP
// Sets an element of the application data assigned to the FSM context: enable short log
action("f_EPTF_LGenBase_ILog_step_shortLogNext->");
f_EPTF_LGenBase_ILog_step_shortLogNext(vl_testStepArgs1);
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, -1);
// [6] disable shortlog vithout valid chain
// ---------------------------------------------------------------------------------------------------------
// disableShortLog STEP
// Disable short log: sets an element of the application data assigned to the FSM context.
action("f_EPTF_LGenBase_ILog_disableShortLog->");
f_EPTF_LGenBase_ILog_disableShortLog(vl_testStepArgs1);
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, -1);
// [7] new chain for second header and log failed vithout log data
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_LGenBase_ILog_newChains->");
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_ILog_entityIdx2, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_second_detailed), pl_paramDetailed := {c_ILog_entityIdx2, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_second_short), pl_paramShort := {c_ILog_entityIdx2, vl_tIdx});
// getcheck
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx2, vl_tIdx, 1);
// logFailed STEP
action("f_EPTF_LGenBase_ILog_step_logFailed->");
f_EPTF_LGenBase_ILog_step_logFailed(vl_testStepArgs2);
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx2, vl_tIdx, -1);
// [8] paralell log in 2 independent chain
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_LGenBase_ILog_newChains[1]->");
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_ILog_entityIdx1, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_first_detailed), pl_paramDetailed := {c_ILog_entityIdx1, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_first_short), pl_paramShort := {c_ILog_entityIdx1, vl_tIdx});
action("f_EPTF_LGenBase_ILog_newChains[2]->");
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_ILog_entityIdx2, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_second_detailed), pl_paramDetailed := {c_ILog_entityIdx2, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_second_short), pl_paramShort := {c_ILog_entityIdx2, vl_tIdx});
// reset DB & Log
f_EPTF_ILog_Test_resetDB();
f_EPTF_ILog_Test_resetLog();
action("f_EPTF_LGenBase_ILog_addToChains[1]->0");
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, c_ILog_entityIdx1); // addToILog[0, 0] => 1:detailed
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, 1);
// shortLogNext STEP
action("f_EPTF_LGenBase_ILog_step_shortLogNext[1]->1");
f_EPTF_LGenBase_ILog_step_shortLogNext(vl_testStepArgs1);
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, 1);
action("f_EPTF_LGenBase_ILog_addToChains[1]->1");
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, c_ILog_entityIdx1); // addToILog[0, 1] => 1:detailed + short
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, 1);
action("f_EPTF_LGenBase_ILog_addToChains[2]->0");
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs2, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx2]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, c_ILog_entityIdx2); // addToILog[1, 0] => 2:detailed
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx2, vl_tIdx, 3);
// shortLogNext STEP
action("f_EPTF_LGenBase_ILog_step_shortLogNext[2]->1");
f_EPTF_LGenBase_ILog_step_shortLogNext(vl_testStepArgs2);
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx2, vl_tIdx, 3);
action("f_EPTF_LGenBase_ILog_addToChains[1]->2");
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, c_ILog_entityIdx1); // addToILog[0, 2] => 1: detailed
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, 1);
action("f_EPTF_LGenBase_ILog_addToChains[2]->1");
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs2, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx2]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, c_ILog_entityIdx2); // addToILog[1, 1] => 2: detailed + short
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx2, vl_tIdx, 3);
// logSuccess STEP
action("f_EPTF_LGenBase_ILog_step_logSuccess[1]->");
f_EPTF_LGenBase_ILog_step_logSuccess(vl_testStepArgs1); // 1: short =>
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx1, vl_tIdx, -1);
// logFailed STEP
action("f_EPTF_LGenBase_ILog_step_logFailed[2]->");
f_EPTF_LGenBase_ILog_step_logFailed(vl_testStepArgs2); // 2: short + detailed
f_EPTF_ILog_Test_getCheckChainId(c_ILog_entityIdx2, vl_tIdx, -1);
// GET LOG STR[1]
var charstring vl_logSt1 := f_EPTF_ILog_Test_getLogStr(c_ILog_entityIdx1);
const charstring cl_loxExpected1 := "<<[FIRST:short] ILogHeader: 1 - Short Chain - 0>>"&
"{EPTF_ILog_Test: Event in chain#1 - 1 [1]: Short Chain ({ 0 }): addToILog[0, 1]}"&
// FIXME: fix artf235361 because in f_EPTF_LGenBase_ILog_addToChains->f_EPTF_LGenBase_ILog_addToChainsBase the
// f_EPTF_LGenBase_ILog_disableShortLogBase has been commented out, otherwise this line is not logged
"{EPTF_ILog_Test: Event in chain#1 - 1 [2]: Short Chain ({ 0 }): addToILog[0, 2]}";
action("GET LOG STR[1]:", vl_logSt1);
if(match ( vl_logSt1, cl_loxExpected1 ) == false) {
setverdict(fail, "Log[1] not match: " & log2str(match ( vl_logSt1, cl_loxExpected1 )));
}
// GET LOG STR[2]
var charstring vl_logSt2 := f_EPTF_ILog_Test_getLogStr(c_ILog_entityIdx2);
action("f_EPTF_ILog_Test_getLogStr[2]->", vl_logSt2);
const charstring cl_loxExpected2 := "<<[SECOND:short] ILogHeader: 3 - Short Chain - 1>>"&
"{EPTF_ILog_Test: Event in chain#3 - 2 [1]: Short Chain ({ 1 }): addToILog[1, 1]}"&
"<<[SECOND:detailed] ILogHeader: 4 - Detailed Chain - 1>>"&
"{EPTF_ILog_Test: Event in chain#4 - 2 [0]: Detailed Chain ({ 1 }): addToILog[1, 0]}"&
"{EPTF_ILog_Test: Event in chain#4 - 2 [1]: Detailed Chain ({ 1 }): addToILog[1, 1]}";
action("GET LOG STR[2]:", vl_logSt2);
if(match ( vl_logSt2, cl_loxExpected2 ) == false) {
setverdict(fail, "Log[2] not match: " & log2str(match ( vl_logSt2, cl_loxExpected2 )));
}
// Cleanup
// ---------------------------------------------------------------------------------------------------------
f_EPTF_Base_cleanup_CT();
setverdict(pass);
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_ILog_negative_tests
//
// Purpose: Negative tests of the EPTF_CLL_LGenBase_ILog CLL functions.
//
// Action: The testcase .
//
// Expected Result: pass verdict. The test result is pass if all function operates without any error.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_ILog_negative_tests() runs on EPTF_LGenBase_Test_CT {
// Init
// ---------------------------------------------------------------------------------------------------------
f_EPTF_LGenBase_init(c_ILog_testName);
// Just Magic 8>
// BehaviorType
v_ILog_behavOK := f_EPTF_LGenBase_declareBehaviorType(c_ILog_behavName, -1, null, null, null);
// FSM event
v_ILog_action := f_EPTF_LGenBase_declareFsmEvent(c_ILog_behavName, c_ILog_action);
// Entity
v_dummyInt := f_EPTF_LGenBase_declareEntityType(c_ILog_entityType, {c_ILog_behavName});
v_dummyInt := f_EPTF_LGenBase_createEntityGroup({c_ILog_entityGroup, c_ILog_entityType, 2});
// FSM
var integer vl_tIdx := f_EPTF_LGenBase_declareCompactFsmTable({
name := "iLogTestFsm",
// [0]
stateList := {"idle"},
timerList := {},
table := {
{eventToListen := {v_ILog_behavOK,v_ILog_action,fsm},
cellRow := {
//state[0]==idle
{{{refers(f_EPTF_ILog_Test_msgStep),{}}}, omit,0}
}
}
}
}
);
v_dummyInt := f_EPTF_LGenBase_activateFsm(pl_eIdx:= c_ILog_entityIdx1, pl_tIdx:= vl_tIdx, pl_sIdx:=0, pl_tcIdx:= -1)
v_dummyInt := f_EPTF_LGenBase_activateFsm(pl_eIdx:= c_ILog_entityIdx2, pl_tIdx:= vl_tIdx, pl_sIdx:=0, pl_tcIdx:= -1)
// reset DB
f_EPTF_ILog_Test_resetDB();
// reset Log
f_EPTF_ILog_Test_resetLog();
// Calls <f_EPTF_ILogBase_register_DB>.
v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1] := f_EPTF_ILog_register_DB(refers(f_EPTF_ILog_Test_logItem), {c_ILog_entityIdx1});
v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx2] := f_EPTF_ILog_register_DB(refers(f_EPTF_ILog_Test_logItem), {c_ILog_entityIdx2});
// [1]: Negative tests - new chain
// ---------------------------------------------------------------------------------------------------------
// This function creates a new chains or reuses an existing free chains for short and detailed chains.
// Sets the elements of the application data assigned to the FSM context.
action("f_EPTF_LGenBase_ILog_newChains->NonExist[pl_eAbsIdx]");
/*
RUN ERROR =>
Dynamic test case error: Unbound right operand of integer comparison.
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_idxNonExist, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_first_detailed), pl_paramDetailed := {c_idxNonExist, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_first_short), pl_paramShort := {c_idxNonExist, vl_tIdx});
*/
action("f_EPTF_LGenBase_ILog_newChains->NonExist[pl_fsmCtx]");
/*
RUN ERROR =>
Dynamic test case error: Unbound right operand of integer comparison.
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_entityIdx1, pl_fsmCtx := c_idxNonExist,
pl_logHeaderDetailedFn := refers(f_logHeader_first_detailed), pl_paramDetailed := {c_entityIdx1, c_idxNonExist},
pl_logHeaderShortFn := refers(f_logHeader_first_short), pl_paramShort := {c_entityIdx1, c_idxNonExist});
*/
// [2] Negative tests - invalid calls of f_EPTF_ILog_addToChains
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_LGenBase_ILog_addToChains[1]->NonExist[eIdx]");
var EPTF_LGenBase_TestStepArgs vl_testStepArgsNonExist;
vl_testStepArgsNonExist.eIdx := c_ILog_entityIdx1;
vl_testStepArgsNonExist.refContext.fCtxIdx := vl_tIdx;
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityCtxList: The index is 123, but the value has only 2 elements.
vl_testStepArgsNonExist.eIdx := c_idxNonExist;
f_EPTF_Base_setNegativeTestMode(true);
f_EPTF_Base_setExpectedErrorMsg("Index overflow in a value of type*");
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgsNonExist, v_EPTF_ILog_Test_logItems_dbIds[c_entityIdx1]);
if(v_dummyInt!=c_IList_err){
setverdict( fail, "Invalid returned value in f_EPTF_LGenBase_ILog_addToChains[non exist eIdx]. Should be: ",c_IList_err, " but got: ",v_dummyInt );
}
f_EPTF_Base_setNegativeTestMode(false);
*/
action("f_EPTF_LGenBase_ILog_addToChains[1]->NonExist[fCtxIdx]");
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityFsmCtxList: The index is 123, but the value has only 1 elements.
vl_testStepArgsNonExist.eIdx := c_entityIdx1;
vl_testStepArgsNonExist.refContext.fCtxIdx := c_idxNonExist;
f_EPTF_Base_setNegativeTestMode(true);
f_EPTF_Base_setExpectedErrorMsg("Index overflow in a value of type ");
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgsNonExist, v_EPTF_ILog_Test_logItems_dbIds[c_entityIdx1]);
if(v_dummyInt!=c_IList_err){
setverdict( fail, "Invalid returned value in f_EPTF_LGenBase_ILog_addToChains[non exist fCtxIdx]. Should be: ",c_IList_err, " but got: ",v_dummyInt );
}
f_EPTF_Base_setNegativeTestMode(false);
*/
action("f_EPTF_LGenBase_ILog_addToChains[1]->NonExist[dbId]");
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_Common_Definitions.EPTF_IntegerArray2D: The index is 1, but the value has only 0 elements.
vl_testStepArgsNonExist.refContext.fCtxIdx := vl_tIdx;
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgsNonExist, c_idxNonExist);
if(v_dummyInt!=c_IList_err){
setverdict( fail, "Invalid returned value in f_EPTF_LGenBase_ILog_addToChains[non exist dbId]. Should be: ",c_IList_err, " but got: ",v_dummyInt );
}
*/
// [3] Negative tests - invalid calls of f_EPTF_ILog_getChainId
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_ILog_getChainId[1]->NonExist[pl_eAbsIdx]");
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityCtxList: The index is 123, but the value has only 2 elements.
v_dummyInt := f_EPTF_LGenBase_ILog_getChainId(c_idxNonExist, vl_tIdx, short);
*/
action("f_EPTF_LGenBase_ILog_getChainId[1]->NonExist[pl_fsmCtx]");
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityFsmCtxList: The index is 123, but the value has only 1 elements.
v_dummyInt := f_EPTF_LGenBase_ILog_getChainId(c_entityIdx1, c_idxNonExist, short);
*/
// [4] Negative tests - invalid calls of f_EPTF_ILog_step_logSuccess
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_LGenBase_ILog_step_logSuccess->NonExist[eIdx]");
var EPTF_LGenBase_TestStepArgs vl_testStepArgs1;
vl_testStepArgs1.eIdx := c_ILog_entityIdx1;
vl_testStepArgs1.refContext.fCtxIdx := vl_tIdx;
// reset DB
f_EPTF_ILog_Test_resetDB();
// reset Log
f_EPTF_ILog_Test_resetLog();
// reset chain
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_ILog_entityIdx1, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_first_detailed), pl_paramDetailed := {c_ILog_entityIdx1, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_first_short), pl_paramShort := {c_ILog_entityIdx1, vl_tIdx});
// Add element(s) short and or detailed chain Id(s) to the chains that are given in the input integer list than disable short log.
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, 0); // addToILog[0, 0] => detailed
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityCtxList: The index is 123, but the value has only 2 elements.
vl_testStepArgsNonExist.eIdx := c_idxNonExist;
f_EPTF_LGenBase_ILog_step_logSuccess(vl_testStepArgsNonExist);
*/
f_EPTF_LGenBase_ILog_step_deleteLog(vl_testStepArgs1);
// [5] Negative tests - invalid calls of f_EPTF_ILog_step_logFailed
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_LGenBase_ILog_step_logFailed->NonExist[eIdx]");
// reset DB
f_EPTF_ILog_Test_resetDB();
// reset Log
f_EPTF_ILog_Test_resetLog();
// reset chain
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_ILog_entityIdx1, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_first_detailed), pl_paramDetailed := {c_ILog_entityIdx1, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_first_short), pl_paramShort := {c_ILog_entityIdx1, vl_tIdx});
// Add element(s) short and or detailed chain Id(s) to the chains that are given in the input integer list than disable short log.
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, 0); // addToILog[0, 0] => detailed
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityCtxList: The index is 123, but the value has only 2 elements.
vl_testStepArgsNonExist.eIdx := c_idxNonExist;
f_EPTF_LGenBase_ILog_step_logFailed(vl_testStepArgsNonExist);
action("***", v_dummyInt);
*/
f_EPTF_LGenBase_ILog_step_deleteLog(vl_testStepArgs1);
// [6] Negative tests - invalid calls of f_EPTF_ILog_step_deleteLog
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_ILog_step_deleteLog->NonExist[eIdx]");
// reset DB
f_EPTF_ILog_Test_resetDB();
// reset Log
f_EPTF_ILog_Test_resetLog();
// reset chain
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_ILog_entityIdx1, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_first_detailed), pl_paramDetailed := {c_ILog_entityIdx1, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_first_short), pl_paramShort := {c_ILog_entityIdx1, vl_tIdx});
// Add element(s) short and or detailed chain Id(s) to the chains that are given in the input integer list than disable short log.
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, 0); // addToILog[0, 0] => detailed
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityCtxList: The index is 123, but the value has only 2 elements.
vl_testStepArgsNonExist.eIdx := c_idxNonExist;
f_EPTF_LGenBase_ILog_step_deleteLog(vl_testStepArgsNonExist);
*/
f_EPTF_LGenBase_ILog_step_deleteLog(vl_testStepArgs1);
// [7] Negative tests - invalid calls of f_EPTF_ILog_step_shortLogNext
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_ILog_step_shortLogNext->NonExist[eIdx]");
// reset DB
f_EPTF_ILog_Test_resetDB();
// reset Log
f_EPTF_ILog_Test_resetLog();
// reset chain
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_ILog_entityIdx1, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_first_detailed), pl_paramDetailed := {c_ILog_entityIdx1, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_first_short), pl_paramShort := {c_ILog_entityIdx1, vl_tIdx});
// Add element(s) short and or detailed chain Id(s) to the chains that are given in the input integer list than disable short log.
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, 0); // addToILog[0, 0] => detailed
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityCtxList: The index is 123, but the value has only 2 elements.
vl_testStepArgsNonExist.eIdx := c_idxNonExist;
f_EPTF_LGenBase_ILog_step_shortLogNext(vl_testStepArgsNonExist);
*/
// No delete for test "There is unprocessed chain data! Please log or delete it previously!" warning in f_EPTF_ILog_newChains
// [8] Negative tests - invalid calls of f_EPTF_ILog_disableShortLog
// ---------------------------------------------------------------------------------------------------------
action("f_EPTF_ILog_disableShortLog->NonExist[eIdx]");
// reset chain
f_EPTF_LGenBase_ILog_newChains(pl_eAbsIdx := c_ILog_entityIdx1, pl_fsmCtx := vl_tIdx,
pl_logHeaderDetailedFn := refers(f_logHeader_first_detailed), pl_paramDetailed := {c_ILog_entityIdx1, vl_tIdx},
pl_logHeaderShortFn := refers(f_logHeader_first_short), pl_paramShort := {c_ILog_entityIdx1, vl_tIdx});
// Add element(s) short and or detailed chain Id(s) to the chains that are given in the input integer list than disable short log.
v_dummyInt := f_EPTF_LGenBase_ILog_addToChains(vl_testStepArgs1, v_EPTF_ILog_Test_logItems_dbIds[c_ILog_entityIdx1]);
f_EPTF_ILog_Test_adToDB(v_dummyInt, 0); // addToILog[0, 0] => detailed
/*
RUN ERROR =>
Dynamic test case error: Index overflow in a value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityCtxList: The index is 123, but the value has only 2 elements.
vl_testStepArgsNonExist.eIdx := c_idxNonExist;
f_EPTF_LGenBase_ILog_disableShortLog(vl_testStepArgsNonExist);
*/
/*
If the f_EPTF_LGenBase_ILog_step_deleteLog steps are not there, it generates a new chain,
and the latest database content is still valid:
<<[FIRST:short] ILogHeader: 9 - Short Chain - 0>>
<<[FIRST:detailed] ILogHeader: 10 - Detailed Chain - 0>>
{EPTF_ILog_Test: Event in chain#10 - 0 [4]: Detailed Chain: addToILog[0, 4]}
otherwise it uses the same chain, so:
<<[FIRST:short] ILogHeader: 1 - Short Chain - 0>>
<<[FIRST:detailed] ILogHeader: 2 - Detailed Chain - 0>>
{EPTF_ILog_Test: Event in chain#2 - 0 [0]: Detailed Chain: addToILog[0, 0]}
- Shouldn't we delete the existing chains in case of f_EPTF_LGenBase_ILog_newChains?
- No, now it sends a warning: "There is unprocessed chain data! Please log or delete it previously!"
*/
// logFailed STEP
action("f_EPTF_LGenBase_ILog_step_logFailed[1]->");
f_EPTF_LGenBase_ILog_step_logFailed(vl_testStepArgs1);
// GET LOG STR[1]
var charstring vl_logSt1 := f_EPTF_ILog_Test_getLogStr(c_ILog_entityIdx1);
action("vl_logSt1->",vl_logSt1);
// Cleanup
// ---------------------------------------------------------------------------------------------------------
/*
In case of a faulty chainID, the f_EPTF_ILog_disableShortLog and the f_EPTF_ILog_step_shortLogNext causes this error:
2012/Jun/19 17:44:17.880719
ERROR EPTF_ILog_Test.ttcn:925(controlpart:EPTF_ILog_Test)->
EPTF_ILog_Test.ttcn:913(testcase:tc_ILog_negative_tests)->
EPTF_CLL_Base_Functions.ttcn:255(function:f_EPTF_Base_cleanup_CT)->
EPTF_CLL_LGenBase_Functions.ttcn:491(function:f_EPTF_LGenBase_cleanup_CT)
Dynamic test case error: Performing sizeof operation on an unbound value of type @EPTF_CLL_LGenBase_Definitions.EPTF_LGenBase_EntityFsmCtxList.
2012. 11. 28.: The contents of EPTF_ILog_Test.ttcn have been moved to this file.
*/
f_EPTF_Base_cleanup_CT();
setverdict(pass);
}
testcase tc_LGenBase_Test_fsmVarAdd ()
runs on EPTF_LGenBase_Test_CT
{
f_LGenBase_Test_negativeFsmVarAddSub(c_EPTF_LGenBase_stepName_fsmVarAdd);
}
testcase tc_LGenBase_Test_fsmVarSub ()
runs on EPTF_LGenBase_Test_CT
{
f_LGenBase_Test_negativeFsmVarAddSub(c_EPTF_LGenBase_stepName_fsmVarSub);
}
function f_LGenBase_Test_negativeFsmVarAddSub(in charstring pl_stepName) runs on EPTF_LGenBase_Test_CT
{
f_EPTF_LGenBase_init("Test_c_EPTF_LGenBase_stepName_fsmVarAdd");
f_EPTF_Base_setExpectedErrorMsg("*Invalid step arguments: *. It should contain at least 3 pairs of variable index and scope*");
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})
var integer vl_varRefIdx := 0;
v_dummyInt := f_EPTF_LGenBase_declareFSMTable({
name := "fsm1",
fsmParams := {
{stateList := {"idle"}},
{timerList := {{"timer", 1.0}}},
{varList := {{"name1",{intVal := 2},FSM},
{"name2",{intVal := 3},FSM},
{"name3",{intVal := 4},FSM}}}
},
table := {
classicTable := {
{eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm},
cellRow := {
{{
{pl_stepName, { stepContextArgs := {vl_varRefIdx, c_EPTF_LGenBase_fsmObjectScopeFSM
/* This would be the correct call of the step:
,vl_varRefIdx+1, c_EPTF_LGenBase_fsmObjectScopeFSM,
vl_varRefIdx+2, c_EPTF_LGenBase_fsmObjectScopeFSM*/}}}
}, omit, omit}
}
}
}
}
})
v_dummyInt := f_EPTF_LGenBase_declareTcType2({
name := "TC_Succ",
fsmName := "fsm1",
entityType := "Entity_Tc_A",
customEntitySucc := ""
})
v_dummyInt := f_EPTF_LGenBase_declareScenarioType3({
name := "sc1",
tcList := {
{ tcName := "TC_Succ",
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);
f_EPTF_Base_cleanup_CT();
}
//////////////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_Test_DS_ConditionHasActiveTc_NoEGSCTC
//
// Purpose: To test the DataSource Client functionality of the
// LGenBase feature that do need no eg/sc/tc declaration
//
// Action: calls f_LGenBase_Test_DataSource(), which test
// only the c_LGenBase_conditionHasActiveTc without
// eg, sc and tc.
//
// Expected Result: pass
/////////////////////////////////////////////////////////////////
testcase tc_LGenBase_Test_DS_ConditionHasActiveTc_NoEGSCTC()
runs on EPTF_LGenBase_DataSourceTest_CT{
f_LGenBase_Test_DataSource(c_fsm1, 0);
}
//////////////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_Test_DS_ConditionHasActiveTc_EGNoSCTC
//
// Purpose: To test the DataSource Client functionality of the
// LGenBase feature that do need no eg/sc/tc declaration
//
// Action: calls f_LGenBase_Test_DataSource(), which test
// only the c_LGenBase_conditionHasActiveTc with eg given
// but without sc and tc.
//
// Expected Result: pass
/////////////////////////////////////////////////////////////////
testcase tc_LGenBase_Test_DS_ConditionHasActiveTc_EGNoSCTC()
runs on EPTF_LGenBase_DataSourceTest_CT{
f_LGenBase_Test_DataSource(c_fsm1, 1);
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_DS_Neg_WrongConditionHasActiveTc
//
// Purpose:
// This is a fake negative test case.
// It tests the DataSourceClient function of LGenBase with this wrong request:
// Data Element: conditionHasActiveTc
// Params: too much params
// A proper warning message should appear.
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_DS_Neg_WrongConditionHasActiveTc() runs on EPTF_LGenBase_DataSourceTest_CT
{
f_LGenBase_Test_wrongConditionRequest(
c_fsm1,
c_LGenBase_conditionHasActiveTc,
{{c_LGenBase_paramNameEntityGroup, "eg1"}});
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_Test_externalTemplates_arithmetic
//
// Purpose:
// Testcase to check the 'external templates' feature arithmetic
//
// Requirement:
// dummy_template.txt external template file is available on filesystem
//
// Action:
// - Loads an external template,
// - creates template set,
// - declares a template type
// - assigns template type to external template,
// - substitutes template with sample values and logs content
// - checks the arithmetic functionality works
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_Test_externalTemplates_arithmetic() runs on EPTF_LGenBase_Test_CT
{
const charstring extTemplName1 := "dummy";
const charstring extTemplName2 := "dummy2";
const charstring extTemplName_dos := "dummy_dos";
const charstring extTemplName_unixFalse := "dummy_unix_false";
var EPTF_LGenBase_ExtTemplLoadList extTemplLoadList := { {extTemplName1, tsp_dummyTemplatePathArithmetic, true},
{extTemplName2, "file_not_exist.txt", false},
{extTemplName_dos, tsp_dummyTemplatePathArithmetic_dos, true},
{extTemplName_unixFalse, tsp_dummyTemplatePathArithmetic, false}
}
// 1. load the external template list
log("Init component and load external template list");
f_EPTF_LGenBase_init("LGenBase Templates Test", pl_extTemplLoadList := extTemplLoadList, pl_enableDefaultArithmeticOperationsInExtTemplate := true);
// check dummy template exist, other one not exist
if ( f_EPTF_LGenBase_getExtTemplIdx(extTemplName1) >= 0
and f_EPTF_LGenBase_getExtTemplIdx(extTemplName_unixFalse) >= 0
and f_EPTF_LGenBase_getExtTemplIdx(extTemplName_dos) >= 0
and f_EPTF_LGenBase_getExtTemplIdx(extTemplName2) == -1 )
{
//check if the endline characters are correctly changed
if ( f_LGenBase_Test_externalTemplates_isDosLineEnd(extTemplName1)
and f_LGenBase_Test_externalTemplates_isDosLineEnd(extTemplName_dos)
and not f_LGenBase_Test_externalTemplates_isDosLineEnd(extTemplName_unixFalse)
) {
log("External template loaded OK");
}
else {
setverdict(fail, "External templates end line characters are not correct");
f_EPTF_Base_stop(none);
}
}
else
{
setverdict(fail, "Could not load external templates");
f_EPTF_Base_stop(none);
}
// 2. create a new template set
log("Create template set");
var integer setId := f_EPTF_LGenBase_createTemplateSet();
if(setId >= 0)
{
log("Template set created OK");
}
else
{
log("Could not create template set");
setverdict(fail);
}
// 3. declare a new template type
log("Declare new template type");
var EPTF_LGenBase_TemplateTypeKey templTypeKey := {"SIP", "INVITE"};
var integer templTypeIdx := f_EPTF_LGenBase_declareTemplateType(templTypeKey, {"USERNAME"}, {"USERID"})
if ( templTypeIdx>=0 )
{
log("Template type declared OK");
}
else
{
log("Could not declare template type");
setverdict(fail);
}
// 4. assign declared template type to 'dummy' template
log("Assign declared type to external template");
// NOTE: f_EPTF_LGenBase_assignExtTemplToTemplType(setId, templTypeIdx, extTemplIdx) is more efficient
if(f_EPTF_LGenBase_assignExtTemplToTemplType3(setId, templTypeKey, extTemplName1) >= 0)
{
log("Assigment OK");
}
else
{
log("Could not assign template type with external template");
setverdict(fail);
}
// 5 get substituted template content
log("Get substituted template content");
var charstring vl_content1 := "", vl_content2:="";
// 5.1 get content by position-based parameter assign
var integer vl_templateItemIdx := f_EPTF_LGenBase_getTemplateItemIdxFromSet(setId, templTypeIdx);
if (vl_templateItemIdx < 0)
{
log("Template type not found in template set");
setverdict(fail);
}
if(f_EPTF_LGenBase_getTemplateContentFast(setId, vl_templateItemIdx, {"username_0012_a@uri.hu", "myuserid"}, vl_content1))
{
log("Positional parameter substitution done OK");
log("Result:\n", vl_content1);
setverdict(pass);
}
else
{
log("Parameter substitution failed");
setverdict(fail);
}
// 5.2 get content by dictionary-based parameter assign
// NOTE: f_EPTF_LGenBase_getTemplateContent(extTemplIdx, ...) is more efficient
if(f_EPTF_LGenBase_getTemplateContentByExtTemplName(extTemplName1, {{"USERNAME","username_0012_a@uri.hu"},{"USERID","myuserid"}}, vl_content2))
{
log("Dictionary-based parameter substitution done OK");
log("Result:\n", vl_content2);
setverdict(pass);
}
else
{
log("Parameter substitution failed");
setverdict(fail);
}
if(vl_content1 != vl_content2)
{
log("Substituted contents are not equal!");
setverdict(fail);
}
if(vl_content1 != c_LGenBase_TemplateSubstitutionTest_Result)
{
log("Substituted contents are correct!");
setverdict(fail);
}
f_EPTF_Base_cleanup_CT();
}
// functions and component that is needed to check expected warning messages
group CheckExpectedWarning {
private function f_EPTF_LGenBase_Test_ExpectedWarning_init() runs on EPTF_CLL_LGenBase_Test_ExpectedWarning_CT {
if (v_LGenBase_Test_expectedWarningInitialized) {
return;
}
v_LGenBase_Test_expectedWarningInitialized:=true;
v_LGenBase_Test_expectedWarningArrived := false;
v_LGenBase_Test_expectedWarningMsg:="";
f_EPTF_Base_registerCleanup(refers(f_EPTF_LGenBase_Test_ExpectedWarning_cleanup));
f_EPTF_Logging_registerPreambleFn(refers(f_EPTF_LGenBase_Test_ExpectedWarning_checkExpectedWarning_preamble_FT));
}
private function f_EPTF_LGenBase_Test_ExpectedWarning_cleanup() runs on EPTF_CLL_LGenBase_Test_ExpectedWarning_CT {
if (not v_LGenBase_Test_expectedWarningInitialized) {
return;
}
v_LGenBase_Test_expectedWarningInitialized:=false;
if (v_LGenBase_Test_expectedWarningMsg != "" and not v_LGenBase_Test_expectedWarningArrived) {
setverdict(fail,"Expected warning message ",v_LGenBase_Test_expectedWarningMsg," was not logged!");
} else {
setverdict(pass,"Expected warning message was logged");
}
}
public function f_EPTF_LGenBase_Test_ExpectedWarning_setExpectedWarning(in charstring pl_expectedWarningMsg) runs on EPTF_CLL_LGenBase_Test_ExpectedWarning_CT {
if (pl_expectedWarningMsg=="") {
return;
}
f_EPTF_LGenBase_Test_ExpectedWarning_init();
v_LGenBase_Test_expectedWarningMsg := pl_expectedWarningMsg;
}
private function f_EPTF_LGenBase_Test_ExpectedWarning_checkExpectedWarning_preamble_FT(in charstring pl_message) runs on EPTF_CLL_LGenBase_Test_ExpectedWarning_CT {
if (not match(pl_message,pattern "*Warning*")) {
return;
}
action(match(pl_message,pattern v_LGenBase_Test_expectedWarningMsg))
if (match(pl_message,pattern v_LGenBase_Test_expectedWarningMsg)) {
v_LGenBase_Test_expectedWarningArrived := true;
}
}
} // group CheckExpectedWarning
type component EPTF_LGenBase_Test_CheckExpectedWarning_CT extends EPTF_CLL_LGenBase_Test_ExpectedWarning_CT, EPTF_LGenBase_Test_CT {
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_Test_externalTemplates_assignExisting
//
// Purpose:
// Testcase to check the if assign is done for an existing 'external template'
//
// Requirement:
// dummy_template.txt external template file is available on filesystem
//
// Action:
// - Loads an external template,
// - creates template set,
// - declares a template type
// - assigns template type to external template,
// - assigns another template type to the same external template
// - checks the warning
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_Test_externalTemplates_assignExisting() runs on EPTF_LGenBase_Test_CheckExpectedWarning_CT
{
const charstring extTemplName1 := "dummy1";
const charstring extTemplName2 := "dummy2";
var EPTF_LGenBase_ExtTemplLoadList extTemplLoadList := { {extTemplName1, tsp_dummyTemplatePathArithmetic, true},
{extTemplName2, tsp_dummyTemplatePathArithmetic, true}
}
// 1. load the external template list
log("Init component and load external template list");
f_EPTF_LGenBase_init("LGenBase Templates Test", pl_extTemplLoadList := extTemplLoadList, pl_enableDefaultArithmeticOperationsInExtTemplate := true);
f_EPTF_LGenBase_Test_ExpectedWarning_init();
f_EPTF_LGenBase_Test_ExpectedWarning_setExpectedWarning("*Assignment in the template set 0 already exists for template type 0. Assigned template: dummy1. Cannot assign new template: dummy2*");
// check dummy template exist, other one not exist
if ( f_EPTF_LGenBase_getExtTemplIdx(extTemplName1) >= 0
and f_EPTF_LGenBase_getExtTemplIdx(extTemplName2) >= 0 )
{
log("External template loaded OK");
}
else
{
setverdict(fail, "Could not load external templates");
f_EPTF_Base_stop(none);
}
// 2. create a new template set
log("Create template set");
var integer setId := f_EPTF_LGenBase_createTemplateSet();
if(setId >= 0)
{
log("Template set created OK");
}
else
{
log("Could not create template set");
setverdict(fail);
}
// 3. declare a new template type
log("Declare new template type");
var EPTF_LGenBase_TemplateTypeKey templTypeKey := {"SIP", "INVITE"};
var integer templTypeIdx := f_EPTF_LGenBase_declareTemplateType(templTypeKey, {"USERNAME"}, {"USERID"})
if ( templTypeIdx>=0 )
{
log("Template type declared OK");
}
else
{
log("Could not declare template type");
setverdict(fail);
}
// 4. assign declared template type to 'dummy' template
log("Assign declared type to external template");
// NOTE: f_EPTF_LGenBase_assignExtTemplToTemplType(setId, templTypeIdx, extTemplIdx) is more efficient
if(f_EPTF_LGenBase_assignExtTemplToTemplType3(setId, templTypeKey, extTemplName1) >= 0)
{
log("Assigment OK");
}
else
{
log("Could not assign template type with external template");
setverdict(fail);
}
// 5. assigns another template type to the same external template
if(f_EPTF_LGenBase_assignExtTemplToTemplType3(setId, templTypeKey, extTemplName2) >= 0)
{
log("Assigment OK");
setverdict(fail, "Assignment should not be OK");
}
else
{
log("Could not assign template type with external template");
setverdict(pass);
}
f_EPTF_Base_cleanup_CT();
}
type component EPTF_LGenBase_TestPipe_CT extends EPTF_LGenBase_Test_CT{
port PIPEasp_PT v_pipe_PCO;
}
///////////////////////////////////////////////////////////
// Function: f_LGenBase_Test_externalTemplates_isDosLineEnd
//
// Purpose:
// returns if the template end line characters are dos end line characters
//
// Parameters:
// pl_extTemplateName - *in* *charstring* - the name of the template
//
// Return Value:
// if the template contains "\r\n" characters it will be true
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
function f_LGenBase_Test_externalTemplates_isDosLineEnd(in charstring pl_extTemplateName)
runs on EPTF_LGenBase_Test_CT
return boolean {
var charstring vl_content := "";
f_EPTF_LGenBase_getTemplateContentByExtTemplName(pl_extTemplateName, {}, vl_content);
for ( var integer i := 0; i <= lengthof(vl_content) -2; i := i + 1) {
if (substr(vl_content,i,2)== "\r\n") {
return true;
}
}
return false;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_LGenBase_PIPEsend
//
// Purpose:
// Send a bash command through the PIPE testport, and
// return the exit code
//
// Parameters:
// pl_command - *in* *charstring* - the command to execute
// pl_result - *out* <ASP_PResult> - the results of the command
//
// Return Value:
// Exit code from the executed command - usually 0 means success
//
// Detailed Comments:
// The pl_result out parameter can be <unbound> if the return value is not 0
//
///////////////////////////////////////////////////////////
function f_EPTF_LGenBase_PIPEsend(in charstring pl_command, out ASP_PResult pl_result)
runs on EPTF_LGenBase_TestPipe_CT
return integer
{
log("Sending command on PIPE test port: " & pl_command);
const float c_guard := 300.0;
var ASP_PExecute vl_pExecute := { command := "bash ", stdin := pl_command & "; exit" }
v_pipe_PCO.send(vl_pExecute);
timer t_guard;
t_guard.start(c_guard);
alt
{
[] v_pipe_PCO.receive(ASP_PResult:?) -> value pl_result
{
t_guard.stop;
return pl_result.code;
}
[] t_guard.timeout
{
setverdict(fail,"PIPE answer timeout!");
unmap(self:v_pipe_PCO, system:v_pipe_PCO);
f_EPTF_Base_stop();
return 1;
}
}
setverdict(fail,"Shouldn't be reached!");
unmap(self:v_pipe_PCO, system:v_pipe_PCO);
f_EPTF_Base_stop();
return 2;
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_Test_fsmDump
//
// Purpose:
// Testcase to check the 'FSM Dump' feature
//
// Requirement:
// PIPE testport for file-operations
//
// Action:
// - remove FSM dump files,
// - initialize LGenBase,
// - disable the FSMdump functionality,
// - declare an FSM,
// - check if the file is created with disabled dump,
// - enable the FSMdump functionality,
// - declare the FSM again,
// - check if the file has been created correctly,
// - compare the file and the expected output
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_Test_fsmDump() runs on EPTF_LGenBase_TestPipe_CT
{
map(self:v_pipe_PCO, system:v_pipe_PCO)
const ASP_PLineMode c_pLineMode := { lineMode := true };
v_pipe_PCO.send(c_pLineMode);
const charstring cl_dump_files := "fsmdump_*";
// 1. remove FSM dump files
var ASP_PResult vl_result;
if (f_EPTF_LGenBase_PIPEsend("rm -f "&cl_dump_files, vl_result) != 0) {
setverdict(fail,"Error while removing files: "&vl_result.stderr);
unmap(self:v_pipe_PCO, system:v_pipe_PCO);
f_EPTF_Base_stop();
}
// 2. initialize LGenBase
f_EPTF_LGenBase_init("LGenBase FSM Dump Test");
// 3. disable the FSMdump functionality
f_EPTF_LGenBase_setFSMdumpPath("");
// 4. declare an FSM
var EPTF_LGenBase_FsmTableDeclarator vl_fsm := {
name := "FSMTest 1",
fsmParams :=
{{stateList := {"idle"}}},
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_trafficSuccess, omit}},
omit, omit
}
}
}
}
}
}
}
}
f_EPTF_LGenBase_declareFSMTable(vl_fsm);
// 5. check if any file is created with disabled dump
if (f_EPTF_LGenBase_PIPEsend("ls "&cl_dump_files, vl_result) == 0) {
setverdict(fail,"File created when it shouldn't be: "&vl_result.stdout);
unmap(self:v_pipe_PCO, system:v_pipe_PCO);
f_EPTF_Base_stop();
}
// 6. enable the FSMdump functionality
f_EPTF_LGenBase_setFSMdumpPath(".");
// 7. declare the FSM again
vl_fsm.name := "FSMTest 2";
f_EPTF_LGenBase_declareFSMTable(vl_fsm);
// 8. check if the file has been created correctly
const charstring cl_expected_filename := "fsmdump_FSMTest_2.cfg"
if (f_EPTF_LGenBase_PIPEsend("ls "&cl_dump_files, vl_result) != 0) {
setverdict(fail,"No dump file is created!");
unmap(self:v_pipe_PCO, system:v_pipe_PCO);
f_EPTF_Base_stop();
}
else {
if (vl_result.stdout != cl_expected_filename) {
setverdict(fail,"Dump file name is '"&vl_result.stdout&"' instead of '"&cl_expected_filename&"'");
unmap(self:v_pipe_PCO, system:v_pipe_PCO);
f_EPTF_Base_stop();
}
}
// 9. compare the file and the expected output
if (f_EPTF_LGenBase_PIPEsend("diff -q expected_fsm_dump.txt "&cl_expected_filename, vl_result) != 0) {
setverdict(fail,"Error: "&vl_result.stdout);
}
unmap(self:v_pipe_PCO, system:v_pipe_PCO);
f_EPTF_Base_cleanup_CT();
setverdict(pass);
}
group DTEHandler_Event4FSM {
function f_EPTF_LGenBase_Test_DTEInTestStep_shouldGenerateDTE(in EPTF_LGenBase_TestStepArgs pl_ptr)
runs on EPTF_LGenBase_Test_CT return boolean
{
// returns true if entity should generate DTE
return pl_ptr.eIdx rem 3 == 1;
}
function f_EPTF_LGenBase_Test_step_start(in EPTF_LGenBase_TestStepArgs pl_ptr)
runs on EPTF_LGenBase_Test_CT
{
action("!!!! started entity: ", pl_ptr.eIdx);
}
function f_EPTF_LGenBase_Test_step_generateDTE(in EPTF_LGenBase_TestStepArgs pl_ptr)
runs on EPTF_LGenBase_Test_CT
{
action("!!!! generateDTE is running for entity: ", pl_ptr.eIdx, " , post/dispatch: ", pl_ptr.stepArgs);
if (not f_EPTF_LGenBase_Test_DTEInTestStep_shouldGenerateDTE(pl_ptr)) {
return; // no DTE
}
//log(%definitionId, " started...");
var integer i := 1;
log(i/(i-1));
}
function f_EPTF_LGenBase_Test_step_checkDTE(in EPTF_LGenBase_TestStepArgs pl_ptr)
runs on EPTF_LGenBase_Test_CT
{
action("!!!! checkDTE is running for entity: ", pl_ptr.eIdx);
v_EventReceived[pl_ptr.eIdx] := v_EventReceived[pl_ptr.eIdx] + 1;
}
///////////////////////////////////////////////////////////
// Testcase: tc_LGenBase_Test_DTEHandler_Event4FSM
//
// Purpose:
// Testcase to check if events are handled correctly for entities that generated DTE before
//
// Requirement:
// -
//
// Action:
// - start traffic case
// - entity 1 generates DTE
// - traffic case finishes
// - entity 1 enabled
// - traffic case started
// - number of starts checked
//
// Description:
// This test checks correct behaviour for artifact artf636751.
// Test case should pass
// The original code generated DTE when the traffic case was started
//
///////////////////////////////////////////////////////////
testcase tc_LGenBase_Test_DTEHandler_Event4FSM () runs on EPTF_LGenBase_Test_CT {
f_EPTF_LGenBase_init("DTEHandler_Event4FSM");
const charstring cl_behaviorName := "DTEHandler_Event4FSM_behavior";
const charstring cl_entityType := "DTEHandler_Event4FSM_entityType";
const charstring cl_entityGrp := "DTEHandler_Event4FSM_entityGrp";
const charstring cl_fsmName := "DTEHandler_Event4FSM_FSM";
const charstring cl_stepName_start := "DTEHandler_Event4FSM_step_start";
const charstring cl_stepName_generateDTE := "DTEHandler_Event4FSM_step_generateDTE";
const charstring cl_stepName_checkDTE := "DTEHandler_Event4FSM_step_checkDTE";
const charstring cl_trafficCase := "DTEHandler_Event4FSM_trafficCase";
const charstring cl_scenario := "DTEHandler_Event4FSM_scenario";
// BehaviorType
v_myBCtxIdx := f_EPTF_LGenBase_declareBehaviorType(cl_behaviorName, -1, null, null, null);
// FSM event
// Declare Step
f_EPTF_LGenBase_declareStep(cl_behaviorName, {cl_stepName_start,refers(f_EPTF_LGenBase_Test_step_start)})
f_EPTF_LGenBase_declareStep(cl_behaviorName, {cl_stepName_generateDTE,refers(f_EPTF_LGenBase_Test_step_generateDTE)})
f_EPTF_LGenBase_declareStep(cl_behaviorName, {cl_stepName_checkDTE,refers(f_EPTF_LGenBase_Test_step_checkDTE)})
// Entity
v_dummyInt := f_EPTF_LGenBase_declareEntityType(cl_entityType, {cl_behaviorName});
v_dummyInt := f_EPTF_LGenBase_createEntityGroup({cl_entityGrp, cl_entityType, 3});
// FSM
var integer vl_tIdx := f_EPTF_LGenBase_declareCompactFsmTable({
name := cl_fsmName,
// [0]
stateList := {"idle"},
timerList := {},
table := {
{eventToListen := {c_EPTF_LGenBase_bIdx,c_EPTF_LGenBase_inputIdx_testMgmt_startTC,fsm},
cellRow := {
//state[0]==idle
{
{
{refers(f_EPTF_LGenBase_Test_step_start),{}},
{refers(f_EPTF_LGenBase_Test_step_generateDTE),{}},
{refers(f_EPTF_LGenBase_Test_step_checkDTE),{}},
{refers(f_EPTF_LGenBase_step_trafficSuccess),{}}
},
omit,
0
}
}
},
{eventToListen := {c_EPTF_LGenBase_bIdx,c_EPTF_LGenBase_inputIdx_testMgmt_trafficCaseStarted,general},
cellRow := {
//state[0]==idle
{
{
{refers(f_EPTF_LGenBase_Test_step_start),{}}
},
omit,
0
}
}
}
}
});
v_dummyInt := f_EPTF_LGenBase_declareTcType2(
{
name := cl_trafficCase,
fsmName := cl_fsmName,
entityType := cl_entityType,
customEntitySucc := ""
});
v_dummyInt := f_EPTF_LGenBase_declareScenarioType3(
{
name := cl_scenario,
tcList := {
{
tcName := cl_trafficCase,
tcParamsList := {
{target := {cpsToReach := 3.0}},
{scheduler := { preDefinedName := orig }},
{enableEntitiesAtStart := true},
{enabledAtStart := true},
{trafficStartFinish := {{nrOfSuccesses := {10,{}} }}} // condition for tc finish
}
}
},
scParamsList := {}
});
f_EPTF_LGenBase_createScenario2EntityGroup( { cl_entityGrp, cl_scenario } );
var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName := cl_entityGrp, pl_scName := cl_scenario, pl_tcName := cl_trafficCase);
for (var integer i := 0; i < 3; i := i + 1) {
v_EventReceived[i] := 0;
}
timer t_finish := 5.0;
t_finish.start;
t_finish.timeout;
f_EPTF_LGenBase_enableEntityInTrafficCase(vl_tcIdx, 1);
action("!!!! traffic case start - begin ");
f_EPTF_LGenBase_startTrafficCase( cl_entityGrp, cl_scenario, cl_trafficCase);
action("!!!! traffic case start - finish ");
// fix: eventHandling:4946
t_finish.start;
t_finish.timeout;
// check v_EventReceived counters and set verdict
action("v_EventReceived: ", v_EventReceived);
if (v_EventReceived != {10, 0 , 10}) {
setverdict(fail,"Number of traffic success is incorrect: ", v_EventReceived, " should be: {10, 0, 10}");
} else {
setverdict(pass);
}
f_EPTF_Base_stop(pl_verdict := none);
}
} //group DTEHandler_Event4FSM
control {
execute(tc_LGenBase_DS_Neg_WrongConditionIsScPresent1());
execute(tc_LGenBase_DS_Neg_WrongConditionIsScPresent2());
execute(tc_LGenBase_DS_Neg_WrongConditionIsScPresent3());
execute(tc_LGenBase_DS_Neg_WrongConditionIsTcPresent1());
execute(tc_LGenBase_DS_Neg_WrongConditionIsTcPresent2());
execute(tc_LGenBase_DS_Neg_WrongConditionIsTcPresent3());
execute(tc_LGenBase_DS_Neg_WrongdataElementTcEnabledAtStartup1());
execute(tc_LGenBase_DS_Neg_WrongdataElementTcEnabledAtStartup2());
execute(tc_LGenBase_DS_Neg_WrongdataElementTcEnabledAtStartup3());
execute(tc_LGenBase_ILog_tests());
execute(tc_LGenBase_ILog_negative_tests());
execute(tc_LGenBase_Test_fsmVarAdd());
execute(tc_LGenBase_Test_fsmVarSub());
execute(tc_LGenBase_Test_DS_ConditionHasActiveTc_NoEGSCTC());
execute(tc_LGenBase_Test_DS_ConditionHasActiveTc_EGNoSCTC());
execute(tc_LGenBase_DS_Neg_WrongConditionHasActiveTc());
execute(tc_LGenBase_Test_externalTemplates_arithmetic());
execute(tc_LGenBase_Test_externalTemplates_assignExisting());
execute(tc_LGenBase_Test_fsmDump());
execute(tc_LGenBase_Test_DTEHandler_Event4FSM());
}
}