| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // 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_StatHandler_Test_Functions |
| // |
| // Purpose: |
| // This module contains basic tests for the EPTF StatHandler feature. |
| // |
| // Module depends on: |
| // <EPTF_CLL_StatHandler_Definitions> |
| // <EPTF_CLL_StatHandler_Functions> |
| // <EPTF_CLL_StatHandlerClient_Definitions> |
| // <EPTF_CLL_StatHandlerClient_Functions> |
| // <EPTF_CLL_StatHandlerLogging_Definitions> |
| // <EPTF_CLL_StatHandlerLogging_Functions> |
| // <EPTF_CLL_StatHandlerUI_Definitions> |
| // <EPTF_CLL_StatHandlerUI_Functions> |
| // <EPTF_CLL_Base_Functions> |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_CLL_UIHandler_Definitions> |
| // <EPTF_CLL_UIHandler_WidgetFunctions> |
| // <EPTF_CLL_UIHandlerClient_Definitions> |
| // <EPTF_CLL_UIHandlerClient_Functions> |
| // <EPTF_CLL_Logging_Functions> |
| // <EPTF_CLL_LoggingUI_Definitions> |
| // <EPTF_CLL_LoggingUI_Functions> |
| // <EPTF_CLL_LoggingUIClient_Functions> |
| // <EPTF_CLL_Variable_Definitions> |
| // <EPTF_CLL_Variable_Functions> |
| // <XTDP_PDU_Defs> |
| // |
| // Module Parameters: |
| // - |
| // |
| // Current Owner: |
| // Jeno Balasko (ETHBAAT) |
| // |
| // Last Review Date: |
| // 2009-05-22 |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////// |
| |
| module EPTF_StatHandler_Test_Functions { |
| |
| import from EPTF_CLL_StatHandler_Definitions all; |
| import from EPTF_CLL_StatHandler_Functions all; |
| import from EPTF_CLL_StatHandlerClient_Definitions all; |
| import from EPTF_CLL_StatHandlerClient_Functions all; |
| import from EPTF_CLL_StatHandlerLogging_Definitions all; |
| import from EPTF_CLL_StatHandlerLogging_Functions all; |
| import from EPTF_CLL_StatHandlerUI_Definitions all; |
| import from EPTF_CLL_StatHandlerUI_Functions all; |
| |
| import from EPTF_CLL_HashMapStr2Int_Functions all; |
| import from EPTF_CLL_Base_Functions all; |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_UIHandler_Definitions all; |
| import from EPTF_CLL_UIHandler_WidgetFunctions all; |
| import from EPTF_CLL_UIHandler_XULFunctions all; |
| import from EPTF_CLL_UIHandlerClient_Definitions all; |
| import from EPTF_CLL_UIHandlerClient_Functions all; |
| import from EPTF_CLL_Logging_Functions all; |
| import from EPTF_CLL_LoggingUI_Definitions all; |
| import from EPTF_CLL_LoggingUI_Functions all; |
| import from EPTF_CLL_LoggingUIClient_Functions all; |
| import from EPTF_CLL_StatMeasure_Functions all; |
| import from EPTF_CLL_Variable_Definitions all; |
| import from EPTF_CLL_Variable_Functions all; |
| import from EPTF_StatHandler_Test_Definitions all; |
| import from EPTF_CLL_DataSource_Functions all; |
| import from EPTF_CLL_DataSource_Definitions all; |
| |
| |
| group BasicTest { |
| type component SYSTEM_CT extends EPTF_UIHandler_CT, EPTF_LoggingUI_CT, EPTF_LoggingUIClient_CT |
| { |
| var integer v_startBecauseDSIsReady := 0; |
| } |
| |
| type component StatHandlerClientUI_TestCT extends EPTF_StatHandlerClientUI_CT |
| { |
| var integer v_intStat := 0, v_intStat2 := 0; |
| var integer v_varIdx := -1, v_varIdx2 := -1; |
| |
| } |
| |
| function f_StatHandlerUI_testGUI_Client_resetCallback() |
| runs on StatHandlerClientUI_TestCT |
| { |
| v_intStat := 0;v_intStat2:=0; |
| f_EPTF_Var_adjustContent(v_varIdx, {intVal:=v_intStat}); |
| log("Reset has been called!") |
| } |
| |
| function f_StatHandlerUI_testGUI_Client( |
| in charstring pl_selfName, |
| in float pl_statRefresh, |
| in integer pl_statIncrement, |
| in EPTF_StatHandler_CT pl_statHandler_compRef := null, |
| in EPTF_UIHandler_CT pl_uiHandler_compRef := null, |
| in EPTF_LoggingUI_CT pl_loggingUi_compRef := null) |
| runs on StatHandlerClientUI_TestCT |
| { |
| f_EPTF_StatHandlerClientUI_init_CT(pl_selfName, pl_statHandler_compRef, pl_uiHandler_compRef, pl_loggingUi_compRef); |
| v_intStat := 0; |
| f_EPTF_StatHandlerClient_registerResetFunction(refers(f_StatHandlerUI_testGUI_Client_resetCallback)); |
| f_EPTF_Var_newInt("var1", v_intStat, v_varIdx); |
| f_EPTF_Var_newIntRef("var2", v_intStat2, v_varIdx2); |
| f_EPTF_StatHandlerClient_declareStat("MyStat", c_EPTF_StatHandler_Method_Sum, {intVal:=0}); |
| f_EPTF_StatHandlerClient_declareStat("MyStat2", c_EPTF_StatHandler_Method_Sum, {intVal:=0}); |
| f_EPTF_StatHandlerClient_registerStat_IntSum("var1","MyStat"); |
| f_EPTF_StatHandlerClient_registerStat_IntSum("var2","MyStat2"); |
| while(true) { |
| f_StatHandler_Test_wait(pl_statRefresh); |
| v_intStat := v_intStat + pl_statIncrement; |
| v_intStat2 := v_intStat2 + pl_statIncrement; |
| f_EPTF_Var_adjustContent(v_varIdx, {intVal:=v_intStat}); |
| |
| } |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| function EPTF_StatHandlerUI_testGUI_Server_statDeclared( |
| in charstring pl_statName, |
| in charstring pl_statMethod, |
| in integer pl_statVarIdx) |
| runs on EPTF_StatHandlerUI_CT |
| { |
| var charstring vl_widgetId := "testGUI."&pl_statName; |
| |
| var charstring vl_xmlStr := " |
| <tq0001:Widgets xmlns:tq0001='http://ttcn.ericsson.se/protocolModules/xtdp/xtdl'> |
| <tq0001:treeitem> |
| <tq0001:treerow> |
| <tq0001:treecell id='"&vl_widgetId&"_name"&"' label='"&pl_statName&"' tooltiptext='Name of the statistics'/> |
| <tq0001:treecell id='"&vl_widgetId&"' label='' tooltiptext='Value of the statistics'/> |
| </tq0001:treerow> |
| </tq0001:treeitem> |
| </tq0001:Widgets> |
| "; |
| |
| if(sr_Fail == f_EPTF_UIHandlerClient_createGUI(vl_xmlStr, f_EPTF_Base_selfName()&"_stats"&"_tree")) { |
| log(%definitionId, ": cannot add element to gui: ", vl_xmlStr); |
| } |
| |
| f_EPTF_UIHandlerClient_subscribeMe( |
| f_EPTF_Var_getName(pl_statVarIdx), |
| "testGUI."&pl_statName,// gui var name |
| vl_widgetId, // widget name |
| realtime); |
| } |
| |
| function f_EPTF_StatHandlerUI_testGUI_Server_initStatsGUI( |
| in charstring pl_selfName, in charstring pl_parentWidgetId) |
| runs on EPTF_StatHandlerUI_CT |
| { |
| var EPTF_UIHandlerClient_SubsRet vl_addRet := sr_Fail; |
| var charstring vl_statpanel_id := pl_selfName & "_stats"; |
| var charstring vl_tree_id := vl_statpanel_id&"_tree"; |
| var charstring vl_xmlStr := " |
| <tq0001:Widgets xmlns:tq0001='http://ttcn.ericsson.se/protocolModules/xtdp/xtdl'> |
| <tq0001:tabpage id='"&vl_statpanel_id&"' label='"&vl_statpanel_id&"' orientation='vertical'/> |
| </tq0001:Widgets> |
| " |
| var integer vl_resetVarGlobal := -1; |
| |
| vl_addRet := f_EPTF_UIHandlerClient_createGUI(vl_xmlStr, pl_parentWidgetId); |
| |
| if(sr_Success != vl_addRet) { |
| f_EPTF_Logging_error(true,log2str(%definitionId, |
| ": cannot add element to gui (", vl_addRet, "): ", vl_xmlStr)); |
| } |
| |
| vl_xmlStr := " |
| <tq0001:Widgets xmlns:tq0001='http://ttcn.ericsson.se/protocolModules/xtdp/xtdl'> |
| <tq0001:tree hidecolumnpicker='false' id='"&vl_tree_id&"' rows='0.000000'> |
| <tq0001:treecols> |
| <tq0001:treecol editable='false' flex='4.000000' label='Statname' widgetType='string'/> |
| <tq0001:treecol editable='true' flex='1.000000' label='Statistics' widgetType='string'/> |
| </tq0001:treecols> |
| <tq0001:treechildren/> |
| </tq0001:tree> |
| </tq0001:Widgets> |
| "; |
| |
| |
| vl_addRet := f_EPTF_UIHandlerClient_createGUI(vl_xmlStr, vl_statpanel_id); |
| |
| if(sr_Success != vl_addRet) { |
| f_EPTF_Logging_error(true,log2str(%definitionId, |
| ": cannot add element to gui (", vl_addRet, "): ", vl_xmlStr)); |
| } |
| |
| f_EPTF_StatHandler_registerStatDeclaredCallbackFn(refers(EPTF_StatHandlerUI_testGUI_Server_statDeclared)); |
| } |
| |
| |
| function f_EPTF_StatHandler_Test_DataSourceClientReady( |
| in charstring pl_source, |
| in charstring pl_ptcName) |
| runs on SYSTEM_CT{ |
| action("Ready received"); |
| v_startBecauseDSIsReady := v_startBecauseDSIsReady + 1; |
| } |
| |
| function f_StatHandlerUI_testcustomGUI_Server( |
| in charstring pl_selfName, |
| in charstring pl_uiParentWidgetId, |
| in EPTF_UIHandler_CT pl_uiHandler_compRef, |
| in EPTF_LoggingUI_CT pl_loggingUi_compRef := null) |
| runs on EPTF_StatHandlerUI_CT |
| { |
| f_EPTF_StatHandler_init_CT(pl_selfName,pl_uiHandler_compRef); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| function f_StatHandlerUI_testGUI_Server( |
| in charstring pl_selfName, |
| in charstring pl_uiParentWidgetId, |
| in EPTF_UIHandler_CT pl_uiHandler_compRef, |
| in EPTF_LoggingUI_CT pl_loggingUi_compRef := null) |
| runs on EPTF_StatHandlerUI_CT |
| { |
| f_EPTF_StatHandlerUI_init_CT(pl_selfName, pl_uiParentWidgetId, pl_uiHandler_compRef, pl_loggingUi_compRef); |
| f_EPTF_StatHandlerUI_testGUI_Server_initStatsGUI(pl_selfName,tsp_EPTF_GUI_Main_Tabbox_WidgetId) |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| |
| function f_StatHandlerUI_testGUI_initGui() runs on SYSTEM_CT{ |
| |
| var charstring vl_xmlStr := " |
| <tq0001:Widgets xmlns:tq0001='http://ttcn.ericsson.se/protocolModules/xtdp/xtdl'> |
| <tq0001:tabpages id='"&tsp_EPTF_GUI_Main_Tabbox_WidgetId&"' layout='LISTCARD'/> |
| </tq0001:Widgets> |
| "; |
| log(%definitionId&": mainWindow: ", vl_xmlStr); |
| f_EPTF_UIHandler_createGUI( vl_xmlStr, ""); |
| } |
| |
| //================================================================ |
| // f_StatHandler_Test_UI_customGui |
| //================================================================ |
| function f_StatHandler_Test_UI_customGui() |
| runs on SYSTEM_CT |
| { |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_StatHandler_Test_DataSourceClientReady )); |
| f_EPTF_UIHandler_clearGUI(); |
| f_EPTF_UIHandler_addWindow(); |
| |
| var EPTF_StatHandlerUI_CT vl_server1 := EPTF_StatHandlerUI_CT.create; |
| vl_server1.start(f_StatHandlerUI_testcustomGUI_Server( |
| "StatHandlerUI_testGUI_Server1", |
| tsp_EPTF_GUI_Main_Tabbox_WidgetId, |
| self |
| )); |
| var EPTF_StatHandlerUI_CT vl_server2 := EPTF_StatHandlerUI_CT.create; |
| vl_server2.start(f_StatHandlerUI_testcustomGUI_Server( |
| "StatHandlerUI_testGUI_Server2", |
| tsp_EPTF_GUI_Main_Tabbox_WidgetId, |
| self |
| )); |
| |
| timer T_guard, T_alt; |
| T_guard.start( 100.0 ); |
| T_alt.start( 0.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| f_EPTF_Base_stopAll(); |
| } |
| [v_startBecauseDSIsReady > 1] T_alt.timeout{} |
| }; |
| |
| f_EPTF_UIHandler_createGUIFromFile(tsp_StatHandler_guiXmlName, tsp_EPTF_GUI_Main_Window_WidgetId); |
| |
| var StatHandlerClientUI_TestCT vl_client1 := StatHandlerClientUI_TestCT.create; |
| vl_client1.start(f_StatHandlerUI_testGUI_Client("StatHandlerUI_testGUI_Client1", 0.3, 4, vl_server1, self, self)); |
| f_StatHandler_Test_wait(1.5); |
| var StatHandlerClientUI_TestCT vl_client2 := StatHandlerClientUI_TestCT.create; |
| vl_client2.start(f_StatHandlerUI_testGUI_Client("StatHandlerUI_testGUI_Client2", 1.2, 7, vl_server1, self, self)); |
| f_StatHandler_Test_wait(10.0); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| //================================================================ |
| // f_StatHandler_Test_dataSourceTest |
| //================================================================ |
| function f_StatHandler_Test_dataSourceTest() |
| runs on SYSTEM_CT |
| { |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_StatHandler_Test_DataSourceClientReady )); |
| f_EPTF_UIHandler_clearGUI(); |
| f_EPTF_UIHandler_addWindow(); |
| |
| var EPTF_StatHandlerUI_CT vl_server1 := EPTF_StatHandlerUI_CT.create; |
| vl_server1.start(f_StatHandlerUI_testcustomGUI_Server( |
| "StatHandlerUI_testGUI_Server1", |
| tsp_EPTF_GUI_Main_Tabbox_WidgetId, |
| self |
| )); |
| |
| timer T_guard, T_alt; |
| T_guard.start( 100.0 ); |
| T_alt.start( 0.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| f_EPTF_Base_stopAll(); |
| } |
| [v_startBecauseDSIsReady > 1] T_alt.timeout{} //need to wait UIhandler and StatHandler too |
| }; |
| f_EPTF_StatHandler_Test_requestDataAndCheck( c_StatHandler_dataElementResetComponent, { }, {}, true, "0"); |
| f_EPTF_StatHandler_Test_requestDataAndCheck( c_StatHandler_dataElementResetAll, { }, {}, true, "0"); |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| function f_EPTF_StatHandler_Test_requestDataAndCheck( in charstring pl_elementName, |
| in EPTF_CharstringList pl_result, |
| in EPTF_DataSource_Params pl_params := {}, |
| in boolean pl_dataElement := false, |
| in charstring pl_dataElementResult := "" |
| ) runs on SYSTEM_CT { |
| |
| var charstring vl_varName; |
| var charstring vl_dataProviderName := c_StatHandler_DataSource_sourceId; |
| |
| var integer vl_retCode := 0; |
| vl_retCode :=f_EPTF_DataSource_getData( |
| pl_dataVarName := vl_varName, |
| pl_source := vl_dataProviderName, |
| pl_ptcName := "", |
| pl_element := pl_elementName, |
| pl_params := pl_params |
| ); |
| |
| if (pl_dataElement == false){ |
| if (0!=vl_retCode) { |
| setverdict(fail,"Cannot get iterator for dataSource := "&vl_dataProviderName&", ptcName :=", f_EPTF_Base_selfName() & ", element := " & pl_elementName); |
| return; |
| }; |
| |
| var integer vl_varIdx := f_EPTF_Var_getId(vl_varName); |
| var EPTF_CharstringList vl_iList := f_EPTF_Var_getCharstringlistValue(vl_varIdx); |
| |
| if (sizeof(vl_iList) != sizeof(pl_result)){ |
| setverdict(fail, pl_elementName & ": Result is: " & log2str(pl_result) & " instead of "& log2str(vl_iList)); |
| return; |
| } |
| |
| var integer vl_bool := 0; |
| |
| for(var integer i := 0; i < sizeof(vl_iList); i := i + 1){ |
| vl_bool := 0; |
| |
| for(var integer j := 0; j < sizeof(pl_result); j := j + 1){ |
| if (vl_iList[i] == pl_result[j]){ |
| vl_bool := vl_bool + 1; |
| continue; |
| } |
| |
| } |
| if(vl_bool != 1){ |
| for(var integer k := 0; k < sizeof(vl_iList); k := k + 1){ |
| if(vl_iList[i] == vl_iList[k]){ vl_bool := vl_bool - 1;} |
| } |
| if(vl_bool != 0){ |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_iList) & " instead of "& log2str(pl_result)); |
| return; |
| } |
| } |
| } |
| } else { |
| if (0!=vl_retCode) { |
| setverdict(fail,"Cannot get dataElement for dataSource := "&vl_dataProviderName&", ptcName :=", f_EPTF_Base_selfName() & ", element := " & pl_elementName); |
| return; |
| }; |
| |
| var integer vl_varIdx := f_EPTF_Var_getId(vl_varName); |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getContent(vl_varIdx, vl_content) |
| if(ischosen(vl_content.floatVal)){ |
| if(pl_dataElementResult != log2str(vl_content.floatVal)){ |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_content.floatVal) & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| if(ischosen(vl_content.charstringVal)){ |
| if(pl_dataElementResult != vl_content.charstringVal){ |
| setverdict(fail,pl_elementName & ": Result is: " & vl_content.charstringVal & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| if(ischosen(vl_content.intVal)){ |
| if(pl_dataElementResult != log2str(vl_content.intVal)){ |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_content.intVal) & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| if(ischosen(vl_content.boolVal)){ |
| if(pl_dataElementResult != log2str(vl_content.boolVal)){ |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_content.boolVal) & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| if(ischosen(vl_content.statusLEDVal)){ |
| if(pl_dataElementResult != log2str(vl_content.statusLEDVal)){ |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_content.statusLEDVal) & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| } |
| } |
| |
| //================================================================ |
| // f_EPTF_StatHandler_Test_wrongDataRequest |
| //================================================================ |
| function f_EPTF_StatHandler_Test_wrongDataRequest(in charstring pl_elementName, |
| in EPTF_DataSource_Params pl_params := {}) |
| runs on SYSTEM_CT |
| { |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_StatHandler_Test_DataSourceClientReady )); |
| f_EPTF_UIHandler_clearGUI(); |
| f_EPTF_UIHandler_addWindow(); |
| |
| var EPTF_StatHandlerUI_CT vl_server1 := EPTF_StatHandlerUI_CT.create; |
| vl_server1.start(f_StatHandlerUI_testcustomGUI_Server( |
| "StatHandlerUI_testGUI_Server1", |
| tsp_EPTF_GUI_Main_Tabbox_WidgetId, |
| self |
| )); |
| |
| timer T_guard, T_alt; |
| T_guard.start( 100.0 ); |
| T_alt.start( 0.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| f_EPTF_Base_stopAll(); |
| } |
| [v_startBecauseDSIsReady > 0] T_alt.timeout{} |
| }; |
| |
| var charstring vl_varName; |
| var charstring vl_dataProviderName := c_StatHandler_DataSource_sourceId; |
| |
| var integer vl_retCode := 0; |
| vl_retCode :=f_EPTF_DataSource_getData( |
| pl_dataVarName := vl_varName, |
| pl_source := vl_dataProviderName, |
| pl_ptcName := "", |
| pl_element := pl_elementName, |
| pl_params := pl_params |
| ); |
| |
| if (0!=vl_retCode) { |
| setverdict(pass, "DataSource query failed as expected with wrong data, dataSource := "&vl_dataProviderName& ", element := " & pl_elementName); |
| }else |
| { |
| setverdict(fail, "DataSource query was succesfull but it shouldn't have been with these values , |
| dataSource := "&vl_dataProviderName& ", element := " & pl_elementName& ", params := "&log2str(pl_params)); |
| } |
| |
| |
| timer T_g2; |
| T_g2.start( 2.0 ); |
| T_g2.timeout; |
| f_EPTF_Base_cleanup_CT(); |
| |
| } |
| |
| |
| |
| //================================================================ |
| // f_StatHandler_Test_UI_Gui |
| //================================================================ |
| function f_StatHandler_Test_UI_Gui() |
| runs on SYSTEM_CT |
| { |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_UIHandler_clearGUI(); |
| f_EPTF_UIHandler_addWindow(); |
| f_StatHandlerUI_testGUI_initGui(); |
| //f_EPTF_LoggingUI_init_CT("MTC", self, tsp_EPTF_GUI_Main_Tabbox_WidgetId); |
| //f_EPTF_LoggingUIClient_init_CT("MTC", self, self); |
| var EPTF_StatHandlerUI_CT vl_server1 := EPTF_StatHandlerUI_CT.create; |
| vl_server1.start(f_StatHandlerUI_testGUI_Server( |
| "StatHandlerUI_testGUI_Server1", |
| tsp_EPTF_GUI_Main_Tabbox_WidgetId, |
| self, |
| null |
| )); |
| var EPTF_StatHandlerUI_CT vl_server2 := EPTF_StatHandlerUI_CT.create; |
| vl_server2.start(f_StatHandlerUI_testGUI_Server( |
| "StatHandlerUI_testGUI_Server2", |
| tsp_EPTF_GUI_Main_Tabbox_WidgetId, |
| self, |
| null |
| )); |
| |
| f_StatHandler_Test_wait(1.5); |
| var StatHandlerClientUI_TestCT vl_client1 := StatHandlerClientUI_TestCT.create; |
| vl_client1.start(f_StatHandlerUI_testGUI_Client("StatHandlerUI_testGUI_Client1", 0.3, 4, vl_server1, self, null)); |
| f_StatHandler_Test_wait(1.5); |
| var StatHandlerClientUI_TestCT vl_client2 := StatHandlerClientUI_TestCT.create; |
| vl_client2.start(f_StatHandlerUI_testGUI_Client("StatHandlerUI_testGUI_Client2", 1.2, 7, vl_server1, self, null)); |
| f_StatHandler_Test_wait(10.0); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| //================================================================ |
| // f_StatHandler_Test_wait |
| //================================================================ |
| function f_StatHandler_Test_wait(in float pl_sec) |
| { |
| timer Tl_wait := pl_sec; |
| Tl_wait.start; |
| Tl_wait.timeout; |
| } |
| //================================================================ |
| // f_StatHandler_Test_getMean |
| //================================================================ |
| function f_StatHandler_Test_getMean(in EPTF_FloatList pl_list) |
| return float |
| { |
| var float vl_mean := 0.0; |
| if(sizeof(pl_list)==0) { return 0.0; } |
| for(var integer i:=0; i<sizeof(pl_list); i:=i+1) { |
| vl_mean := vl_mean + pl_list[i]; |
| } |
| vl_mean := vl_mean / int2float(sizeof(pl_list)); |
| log("Mean of ",pl_list," : ", vl_mean); |
| return vl_mean; |
| } |
| //================================================================ |
| // f_StatHandler_Test_clientMean |
| //================================================================ |
| function f_StatHandler_Test_clientMean( |
| in charstring pl_selfName, |
| in float pl_mean, |
| in integer pl_nofSamples, |
| in EPTF_StatHandler_CT pl_statHandler_compRef := null) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT(pl_selfName, pl_statHandler_compRef); |
| var integer vl_varIdx:=0; |
| f_EPTF_Var_newFloat("mean", pl_mean, vl_varIdx); |
| f_EPTF_Var_newInt("nofSamples", pl_nofSamples, vl_varIdx); |
| f_EPTF_StatHandlerClient_declareStat("MyMean", c_EPTF_StatHandler_Method_Mean, {floatVal:=0.0}); |
| f_EPTF_StatHandlerClient_registerStat_Mean("mean", "nofSamples", "MyMean"); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| }//group BasicTest |
| |
| group RegressionTest { |
| //================================================================ |
| // f_StatHandler_Test_density |
| // Performs the density test for a given subscription mode |
| //================================================================ |
| function f_StatHandler_Test_density(in EPTF_Var_SubscriptionMode pl_subscriptionMode) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| log(">>>f_StatHandler_Test_density stated in subscription mode ", pl_subscriptionMode); |
| var charstring vl_myStatName:="MyStat"; |
| f_EPTF_StatHandlerClient_init_CT(c_myStatHandlerClient); |
| |
| var EPTF_StatHandler_CT vlc_shServer:= EPTF_StatHandler_CT. create; |
| vlc_shServer.start(f_EPTF_StatHandler_Test_MasterBehavior(c_myStatHandlerMaster)); |
| |
| //==== Statistics part ==== |
| var charstring vl_statMethod := c_EPTF_StatHandler_Method_Density; |
| var EPTF_Var_DirectContent |
| vl_defIntegerListVals := { integerlistVal:={0,1,2,3,4,5,6,7,8,9} }, |
| vl_resetIntegerListVals:={ integerlistVal:={1,0,0,0,0,0,0,0,0,0} }; |
| //var EPTF_FloatList vl_boundaries:= { 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.7, 0.8, 0.9 } |
| |
| var boolean vl_success:=f_EPTF_StatHandlerClient_declareStat( |
| vl_myStatName,vl_statMethod, vl_resetIntegerListVals,vlc_shServer); |
| if(not vl_success) { f_EPTF_Base_stop(fail); } |
| |
| var charstring vl_statVarRef:=f_EPTF_StatHandlerClient_getStatVariableRef(vl_myStatName,vlc_shServer); |
| var integer vl_statVarIdx:=-1; |
| var EPTF_Var_DirectContent vl_statValue; |
| //f_EPTF_Var_subscribeRemote(vlc_shServer,vl_statVarRef,pl_subscriptionMode,vl_statVarIdx); |
| //log(">>>vl_statVarRef: ", vl_statVarRef," vl_statVarIdx: ",vl_statVarIdx); |
| |
| //if(not( vl_statVarRef==vl_myStatName and vl_statVarIdx>=0) ){ f_EPTF_Base_stop(fail); } |
| |
| //=== Creates samples==== |
| |
| var EPTF_StatHandler_Test_ShClients vlc_shClients :={} |
| |
| |
| for(var integer i:=1;i<=tsp_StatHandler_Test_nofClients;i:=i+1) { |
| vlc_shClients[i]:= EPTF_StatHandlerClient_CT.create; |
| vlc_shClients[i].start(f_StatHandler_Test_generalClient( |
| c_myStatHandlerClient&int2str(i), |
| vl_myStatName, |
| vl_statMethod, |
| vl_defIntegerListVals, //sample value |
| i, //nofSample |
| vlc_shServer, |
| pl_subscriptionMode)); |
| }//for |
| |
| f_StatHandler_Test_wait(tsp_EPTF_Var_SyncInterval + 1.0); |
| |
| //====checks init value:===== |
| f_EPTF_Var_getRemoteContent(vlc_shServer,vl_statVarRef,vl_statValue); |
| vl_resetIntegerListVals.integerlistVal[0]:=vl_resetIntegerListVals.integerlistVal[0]*tsp_StatHandler_Test_nofClients |
| |
| log(">>>vl_statValue1: ",vl_statValue); |
| log(">>>Expected value1: ",vl_resetIntegerListVals ); |
| f_EPTF_StatHandler_Test_setverdictFromBool(vl_statValue==vl_resetIntegerListVals) |
| log(match( vl_statValue,vl_resetIntegerListVals)); |
| |
| //====Calculates stat:===== |
| for(var integer i:=0;i<10;i:=i+1) { |
| vl_defIntegerListVals.integerlistVal[i]:=vl_defIntegerListVals.integerlistVal[i]*tsp_StatHandler_Test_nofClients |
| } |
| |
| //======== Check the modified stat (y=x, x:=i, mean[i]=1 where i is the i.node====== |
| f_StatHandler_Test_wait(2.0*tsp_EPTF_Var_SyncInterval+2.0); // 1.0 changed - K.I. |
| f_EPTF_Var_getRemoteContent(vlc_shServer,vl_statVarRef,vl_statValue); |
| log(">>>Expected value2: ", vl_defIntegerListVals ); |
| log(">>>FINAL RESULT: vl_statValue: ",vl_statValue); |
| //Check: |
| log(match(vl_statValue,vl_defIntegerListVals)); |
| f_EPTF_StatHandler_Test_setverdictFromBool(vl_statValue==vl_defIntegerListVals); |
| f_EPTF_Base_cleanup_CT(); |
| }//f_ |
| |
| //================================================================ |
| // f_StatHandler_Test_generalClient |
| // Registers a stat with 0.0 then modifies it for pl_value |
| //================================================================ |
| function f_StatHandler_Test_generalClient( |
| in charstring pl_selfName, |
| in charstring pl_statName, |
| in charstring pl_statMethod, //e.g mean |
| in EPTF_Var_DirectContent pl_values, |
| in integer pl_nofSamples, |
| in EPTF_StatHandler_CT pl_statHandler_compRef := null, |
| in EPTF_Var_SubscriptionMode pl_subscriptionMode := sampledAtSync) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| var charstring vl_statVarName:=pl_selfName&"_"&pl_statMethod&"_Samples"; //mean, min, max |
| var charstring vl_nofSamplesName:= pl_selfName&"_"&pl_statMethod&"_nofSamples"; |
| var charstring vl_varianceName:=pl_selfName&"_"&pl_statMethod&"_Variance"; |
| //var EPTF_FloatList vl_boundaries:= { 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.7, 0.8, 0.9 }; |
| var integer vl_boundaryIdx:=-1; |
| f_EPTF_StatHandlerClient_init_CT(pl_selfName, pl_statHandler_compRef); |
| var integer vl_varIdx:=-1, vl_sampleIdx:=-1, vl_varianceIdx:=-1; |
| var EPTF_CharstringList vl_providerVarList:={}; |
| //=== FloatVal=== |
| if(ischosen(pl_values.floatlistVal)){ |
| |
| //mean, min, max, sum: |
| vl_providerVarList[c_EPTF_StatHandler_providerVarIdx_mean]:=vl_statVarName; |
| f_EPTF_Var_newFloat(vl_statVarName, 1.0, vl_varIdx); |
| |
| //==declares:=== |
| f_EPTF_StatHandlerClient_declareStat(pl_statName, pl_statMethod, {floatVal:=0.0}); |
| if(pl_statMethod==c_EPTF_StatHandler_Method_Mean or |
| pl_statMethod==c_EPTF_StatHandler_Method_GlobalAverage) { |
| |
| f_EPTF_Var_newInt(vl_nofSamplesName, pl_nofSamples, vl_sampleIdx); |
| vl_providerVarList[c_EPTF_StatHandler_providerVarIdx_nofSamples]:=vl_nofSamplesName; |
| |
| } else if(pl_statMethod==c_EPTF_StatHandler_Method_StandardDev) { |
| f_EPTF_Var_newInt(vl_nofSamplesName, pl_nofSamples, vl_sampleIdx); |
| vl_providerVarList[c_EPTF_StatHandler_providerVarIdx_nofSamples]:=vl_nofSamplesName; |
| f_EPTF_Var_newFloat(vl_varianceName, 0.0, vl_varianceIdx); |
| vl_providerVarList[c_EPTF_StatHandler_providerVarIdx_S]:=vl_varianceName; |
| } |
| |
| } else if(ischosen(pl_values.integerlistVal)) { |
| |
| if(pl_statMethod==c_EPTF_StatHandler_Method_Density) |
| { |
| vl_statVarName:=pl_selfName&"_"&pl_statMethod&"_densityValues" |
| vl_providerVarList[c_EPTF_StatHandler_providerVarIdx_density]:=vl_statVarName; |
| vl_varIdx:=f_EPTF_Var_newVar( vl_statVarName, { integerlistVal:={1,0,0,0,0,0,0,0,0,0} }); |
| |
| var charstring vl_BoundaryName:=pl_selfName&"_"&pl_statMethod&"_Boundaries"; |
| vl_boundaryIdx:=f_EPTF_Var_newVar( vl_BoundaryName,{ floatlistVal:={ 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.7, 0.8, 0.9 } }); |
| vl_providerVarList[c_EPTF_StatHandler_providerVarIdx_boundaries]:=vl_BoundaryName; |
| } else { |
| log(">>>>>>>Ooops, this is not ready yet 1<<<<<<<") |
| log(">>>Method name: ", pl_statMethod); |
| } |
| } else if(ischosen(pl_values.intVal)) { //inMin, intMax, intSum |
| f_EPTF_Var_newInt(vl_statVarName,0,vl_varIdx); |
| vl_providerVarList[c_EPTF_StatHandler_providerVarIdx_single]:=vl_statVarName; |
| } else { |
| log(">>>>>>>Ooops, this is not ready yet 2<<<<<<<") |
| } |
| |
| //===registers:=== |
| f_EPTF_StatHandlerClient_registerStat(vl_providerVarList, pl_statName,pl_subscriptionMode);//pl_subscriptionMode |
| |
| //===waits=== |
| f_StatHandler_Test_wait(tsp_EPTF_Var_SyncInterval+1.5); // 1.1 changed - K.I. |
| |
| //===modifies content:==== |
| if(ischosen(pl_values.floatlistVal)){ |
| f_EPTF_Var_adjustContent(vl_varIdx, {floatVal:=pl_values.floatlistVal[0]}); |
| if(pl_statMethod==c_EPTF_StatHandler_Method_StandardDev) { |
| f_EPTF_Var_adjustContent(vl_varianceIdx, {floatVal:=pl_values.floatlistVal[1]}); |
| } |
| }else if(ischosen(pl_values.integerlistVal)) { |
| f_EPTF_Var_adjustContent(vl_varIdx, pl_values) |
| } else if(ischosen(pl_values.intVal)) { //inMin, intMax, intSum |
| f_EPTF_Var_adjustContent(vl_varIdx, pl_values) |
| }//if |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| //======================================================= |
| // f_EPTF_StatHandler_Test_setverdictFromBool() |
| //======================================================= |
| function f_EPTF_StatHandler_Test_setverdictFromBool(in boolean pl_result) |
| { |
| if(pl_result==true) { |
| setverdict(pass) |
| } else { |
| setverdict(fail) |
| } |
| }//f_ |
| |
| //======================================================= |
| // f_EPTF_StatHandler_Test_checkMasterInit |
| //======================================================= |
| // FIXME: removed because of private component variables |
| /* function f_EPTF_StatHandler_Test_checkMasterInit(in charstring pl_selfName) runs on EPTF_StatHandler_CT |
| { |
| log("StatHandle init: ", v_EPTF_StatHandler_initialized, " ",v_EPTF_StatHandlerLogging_initialized, " ",v_EPTF_Var_initialized); |
| //flags: |
| f_EPTF_StatHandler_Test_setverdictFromBool( |
| v_EPTF_StatHandler_initialized and v_EPTF_StatHandlerLogging_initialized and v_EPTF_Var_initialized); |
| //arrays,vars: |
| f_EPTF_StatHandler_Test_setverdictFromBool( |
| v_EPTF_StatHandler_aggregatedStats.data=={} and v_EPTF_StatHandler_aggregatedStats.hashmap_name2Idx!=-1) |
| f_EPTF_StatHandler_Test_setverdictFromBool(vd_EPTF_StatHandler_behavior != null); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_resetButtonVarIdx!=-1); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_resetComponents=={}) |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_nofPendingResets==0); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_statDeclaredCallbackFns=={}); |
| //f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_bindStatToWidgetFn!=null); //it will be set later or never |
| //v_EPTF_StatHandler_nameSeparator //not important |
| //hash maps: - |
| var integer vl_id:=-1; |
| var charstring vl_hashName:=pl_selfName&v_EPTF_StatHandler_nameSeparator&c_EPTF_StatHandler_HashMapName2Idx; |
| f_EPTF_StatHandler_Test_setverdictFromBool(f_EPTF_str2int_HashMap_GetID(vl_hashName,vl_id) ); |
| }*/ |
| |
| //======================================================= |
| // f_EPTF_StatHandler_Test_checkMasterCleanup |
| //======================================================= |
| // FIXME: removed because of private component variables |
| /* function f_EPTF_StatHandler_Test_checkMasterCleanup(in charstring pl_selfName) runs on EPTF_StatHandler_CT |
| { |
| var integer vl_id:=-1; |
| f_EPTF_StatHandler_Test_setverdictFromBool( |
| (not v_EPTF_StatHandler_initialized) and (not v_EPTF_StatHandlerLogging_initialized) and (not v_EPTF_Var_initialized)); |
| //arrays,vars: |
| f_EPTF_StatHandler_Test_setverdictFromBool( v_EPTF_StatHandler_aggregatedStats==c_empty_EPTF_StatHandler_AggregatedStatDatabase) |
| f_EPTF_StatHandler_Test_setverdictFromBool(vd_EPTF_StatHandler_behavior == null); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_resetButtonVarIdx==-1); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_resetComponents=={}) |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_nofPendingResets==0); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_statDeclaredCallbackFns=={}); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandler_bindStatToWidgetFn==null); |
| //v_EPTF_StatHandler_nameSeparator |
| //hash maps: - |
| var charstring vl_hashName:=pl_selfName&v_EPTF_StatHandler_nameSeparator&c_EPTF_StatHandler_HashMapName2Idx; |
| if( f_EPTF_str2int_HashMap_GetID(vl_hashName,vl_id) ) |
| { |
| setverdict(fail); |
| f_EPTF_str2int_HashMap_Clear(vl_id); |
| f_EPTF_str2int_HashMap_Delete(vl_hashName); |
| }else{ |
| setverdict(pass); |
| } |
| }*/ |
| |
| //======================================================= |
| // f_EPTF_StatHandler_Test_checkClientInit |
| //======================================================= |
| // FIXME: removed because of private component variables |
| /* function f_EPTF_StatHandler_Test_checkClientInit(in charstring pl_selfName) runs on EPTF_StatHandlerClient_CT |
| { |
| //EPTF_StatHandlerLogging_CT, EPTF_Semaphore_CT, EPTF_Var_CT |
| f_EPTF_StatHandler_Test_setverdictFromBool( |
| v_EPTF_StatHandlerClient_initialized and v_EPTF_StatHandlerLogging_initialized and v_EPTF_Semaphore_initialized and v_EPTF_Var_initialized); |
| |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_defaultMasterCompRef==null); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_connectedCompRefList=={}); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_subscribingCompRefList=={}); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_responseBuffer=={}); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_pendingMessages==0); |
| f_EPTF_StatHandler_Test_setverdictFromBool(vd_EPTF_StatHandlerClient_msgHandler!=null); |
| f_EPTF_StatHandler_Test_setverdictFromBool(vd_EPTF_StatHandlerClient_autoDisconnect==null); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_resetFunctions=={}); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_resetVarIdx==-1); |
| }//f_ |
| */ |
| //======================================================= |
| // f_EPTF_StatHandler_Test_checkClientCleanup |
| //======================================================= |
| // FIXME: removed because of private component variables |
| /* function f_EPTF_StatHandler_Test_checkClientCleanup(in charstring pl_selfName) runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandler_Test_setverdictFromBool( |
| not v_EPTF_StatHandlerClient_initialized and |
| not v_EPTF_StatHandlerLogging_initialized and |
| not v_EPTF_Semaphore_initialized and |
| not v_EPTF_Var_initialized); |
| |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_defaultMasterCompRef==null); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_connectedCompRefList=={}); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_subscribingCompRefList=={}); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_responseBuffer=={}); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_pendingMessages==0); |
| f_EPTF_StatHandler_Test_setverdictFromBool(vd_EPTF_StatHandlerClient_msgHandler==null); |
| f_EPTF_StatHandler_Test_setverdictFromBool(v_EPTF_StatHandlerClient_resetFunctions=={}); |
| if(v_EPTF_StatHandlerClient_resetFunctions!={}) { |
| log(">>>v_EPTF_StatHandlerClient_resetFunctions: ",v_EPTF_StatHandlerClient_resetFunctions); |
| } |
| }//f_ |
| */ |
| //======================================================= |
| // f_EPTF_StatHandler_Test_MasterBehavior |
| //======================================================= |
| function f_EPTF_StatHandler_Test_MasterBehavior(in charstring pl_compName) //, in float pl_timeout) |
| runs on EPTF_StatHandler_CT |
| { |
| f_EPTF_StatHandler_init_CT(pl_compName); |
| |
| // FIXME: removed because of private component variables |
| // f_EPTF_StatHandler_Test_checkMasterInit(pl_compName); |
| setverdict(pass); // assuming the master was initialized correctly |
| |
| f_EPTF_Base_wait4Shutdown() |
| f_EPTF_Base_cleanup_CT(); |
| }//f_ |
| |
| |
| // /////////////////////////////////////////////////////////// |
| // // Function: EPTF_StatHandlerClient_Test_checkFloatStatByIdx |
| // // |
| // // Purpose: |
| // // To compare a float Variable given by its index and a float value |
| // // |
| // // Detailed Comments: |
| // // It sets the verdict to fail if the the values are not equal. |
| // // Its usability is very limited because it is not easy even impossible to predict the exact float result of a calculation. |
| // // Nore usable function is f_EPTF_StatHandler_Test_checkFloatEquality |
| // /////////////////////////////////////////////////////////// |
| // function f_EPTF_StatHandler_Test_checkFloatStatValue( |
| // in integer pl_statIdx_floatVar, |
| // in float pl_expectedValue) |
| // runs on EPTF_StatHandlerClient_CT |
| // { |
| // f_EPTF_StatHandler_Test_setverdictFail( f_EPTF_StatHandler_value2str(pl_statIdx_floatVar)!=float2str(pl_expectedValue)); |
| // } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: EPTF_StatHandler_Test_checkFloatStatByIdx |
| // |
| // Purpose: |
| // checks if abs value of difference of pl_statIdx_floatVar and pl_expectedValue is less than pl_epsilon |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_StatHandler_Test_checkFloatEquality( |
| in float pl_value, |
| in float pl_expectedValue, |
| in float pl_epsilon) |
| { |
| f_EPTF_StatHandler_Test_setverdictFail( (pl_value - pl_expectedValue > pl_epsilon) or (pl_value - pl_expectedValue < -pl_epsilon)); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_StatHandler_Test_getStandardDevSq |
| // |
| // Purpose: |
| // Calculates the square of standard deviation |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| |
| function f_EPTF_StatHandler_Test_getStandardDevSq( in EPTF_FloatList pl_values ) return float { |
| var float vl_mean:=0.0; |
| var integer vl_size:= sizeof(pl_values); |
| var float vl_floatSize:= int2float(vl_size) |
| var float vl_D2 :=0.0; |
| |
| if(vl_size==0) { return 0.0 }; |
| |
| for(var integer i:=0; i<vl_size; i:=i+1) { |
| vl_mean:= vl_mean+ pl_values[i]; |
| } |
| vl_mean:= vl_mean / vl_floatSize; |
| log(">>>Mean: ", vl_mean); |
| for(var integer j:=0;j<vl_size; j:=j+1) { |
| vl_D2:= vl_D2+(pl_values[j]-vl_mean)*(pl_values[j]-vl_mean); |
| } |
| vl_D2:= vl_D2/vl_floatSize; |
| log("StandardDev of ",pl_values," : ", vl_D2); |
| return vl_D2; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_StatHandler_Test_getStandardDev_S |
| // |
| // Purpose: |
| // Calculates the "S" value for standard deviation stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| |
| function f_EPTF_StatHandler_Test_getStandardDev_S( in EPTF_FloatList pl_values ) return float { |
| var float vl_mean:=0.0; |
| var integer vl_size:= sizeof(pl_values); |
| var float vl_floatSize:= int2float(vl_size) |
| var float vl_S :=0.0; |
| |
| if(vl_size==0) { return 0.0 }; |
| |
| for(var integer i:=0; i<vl_size; i:=i+1) { |
| vl_mean:= vl_mean+ pl_values[i]; |
| } |
| vl_mean:= vl_mean / vl_floatSize; |
| log(">>>Mean: ", vl_mean); |
| for(var integer j:=0;j<vl_size; j:=j+1) { |
| vl_S:= vl_S+(pl_values[j]-vl_mean)*(pl_values[j]-vl_mean); |
| } |
| log("StandardDev S of ",pl_values," : ", vl_S); |
| return vl_S; |
| } |
| |
| function f_EPTF_StatHandler_Test_setverdictFail(in boolean pl_condition) { |
| if (pl_condition) { |
| setverdict(fail); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_percentile95_client_HK48363 |
| // |
| // Purpose: |
| // Client behavior function for testing TR HK48363. |
| // |
| // Detailed Comments: |
| // StatHandler causes dynamic test case error if percentile95 provider has no boundaries. |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_percentile95_client_HK48363(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "p95", |
| c_EPTF_StatHandler_Method_Percentile95, |
| {floatVal := 0.0}); |
| var integer idx := 0, i:=0; |
| for(i:=0; i<5; i:=i+1) { |
| f_EPTF_Var_newVar("src"&int2str(i)&".density", {integerlistVal := {0,1,2,3,4,0}}); |
| f_EPTF_Var_newVar("src"&int2str(i)&".boundaries", {floatlistVal := {0.0,0.1,0.2,0.3,0.4}}); |
| f_EPTF_Var_newVar("src"&int2str(i)&".max", {floatVal := 0.33}); |
| if(f_EPTF_StatHandlerClient_registerStat_Percentile95( |
| "src"&int2str(i)&".density", |
| "src"&int2str(i)&".boundaries", |
| "src"&int2str(i)&".max", |
| "p95")) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| } |
| f_EPTF_Var_newVar("fail.density", {integerlistVal := {0,0,0,0,0,0}}); |
| f_EPTF_Var_newVar("fail.boundaries", {floatlistVal := {}}); |
| f_EPTF_Var_newVar("fail.max", {floatVal := 0.0}); |
| if(f_EPTF_StatHandlerClient_registerStat_Percentile95( |
| "fail.density", |
| "fail.boundaries", |
| "fail.max", |
| "p95")) { |
| setverdict(fail); |
| } else { |
| setverdict(pass); |
| } |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_percentileP_client_HK48363 |
| // |
| // Purpose: |
| // Client behavior function for testing TR HK48363. |
| // |
| // Detailed Comments: |
| // StatHandler causes dynamic test case error if percentile95 provider has no boundaries. |
| // This test checks whether percentileP works well |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_percentileP_client_HK48363(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "percentileP", |
| c_EPTF_StatHandler_Method_PercentileP, |
| {floatVal := 0.0}); |
| var integer idx := 0, i:=0; |
| for(i:=0; i<5; i:=i+1) { |
| f_EPTF_Var_newVar("src"&int2str(i)&".density", {integerlistVal := {0,1,2,3,4,0}}); |
| f_EPTF_Var_newVar("src"&int2str(i)&".boundaries", {floatlistVal := {0.0,0.1,0.2,0.3,0.4}}); |
| f_EPTF_Var_newVar("src"&int2str(i)&".max", {floatVal := 0.33}); |
| f_EPTF_Var_newVar("src"&int2str(i)&".pValue", {floatVal := 0.5}); |
| if(f_EPTF_StatHandlerClient_registerStat_PercentileP( |
| "src"&int2str(i)&".density", |
| "src"&int2str(i)&".boundaries", |
| "src"&int2str(i)&".max", |
| "src"&int2str(i)&".pValue", |
| "percentileP")) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| } |
| f_EPTF_Var_newVar("fail.density", {integerlistVal := {0,0,0,0,0,0}}); |
| f_EPTF_Var_newVar("fail.boundaries", {floatlistVal := {}}); // wrong boundaries |
| f_EPTF_Var_newVar("fail.max", {floatVal := 0.0}); |
| f_EPTF_Var_newVar("fail.pValue", {floatVal := 0.5}); |
| if(f_EPTF_StatHandlerClient_registerStat_PercentileP( |
| "fail.density", |
| "fail.boundaries", |
| "fail.max", |
| "fail.pValue", |
| "percentileP")) { |
| setverdict(fail); |
| } else { |
| setverdict(pass); |
| } |
| |
| f_EPTF_Var_newVar("fail2.density", {integerlistVal := {0,0,0,0,0,0}}); |
| f_EPTF_Var_newVar("fail2.boundaries", {floatlistVal := {0.0,0.1,0.2,0.3,0.4}}); |
| f_EPTF_Var_newVar("fail2.max", {floatVal := 0.0}); |
| f_EPTF_Var_newVar("fail2.pValue", {floatVal := 0.95}); // wrong pValue |
| if(f_EPTF_StatHandlerClient_registerStat_PercentileP( |
| "fail2.density", |
| "fail2.boundaries", |
| "fail2.max", |
| "fail2.pValue", |
| "percentileP")) { |
| setverdict(fail); |
| } else { |
| setverdict(pass); |
| } |
| |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| group RegisterAggregatedStat { |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_checkFloatVarContentEquality |
| // |
| // Purpose: |
| // Check Float Var Content Equality |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_checkFloatVarContentEquality( |
| in EPTF_Var_DirectContent pl_content, |
| in float pl_expectedValue, |
| in float pl_epsilon := 0.000001) |
| return boolean |
| { |
| if(not ischosen(pl_content.floatVal)) { |
| log(%definitionId&": not a float value: ", pl_content); |
| return false; |
| } |
| return not ((pl_content.floatVal - pl_expectedValue > pl_epsilon) or (pl_content.floatVal - pl_expectedValue < -pl_epsilon)); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerAggregatedStat_min_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of aggregated stats |
| // as data source to another aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerAggregatedStat_min_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "min_src1", |
| c_EPTF_StatHandler_Method_Min, |
| {intVal := 0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "min_src2", |
| c_EPTF_StatHandler_Method_Min, |
| {intVal := 0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "min_target", |
| c_EPTF_StatHandler_Method_Min, |
| {intVal := 0}); |
| |
| f_EPTF_Var_newVar("src1", {intVal := 27}); |
| f_EPTF_StatHandlerClient_registerStat_IntMin( |
| "src1", |
| "min_src1"); |
| |
| f_EPTF_Var_newVar("src2", {intVal := 6}); |
| f_EPTF_StatHandlerClient_registerStat_IntMin( |
| "src2", |
| "min_src2"); |
| |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "min_src1", |
| "min_target"); |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "min_src2", |
| "min_target"); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("min_target"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(vl_content == {intVal := 6}) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| |
| f_EPTF_Var_adjustContent(f_EPTF_Var_getId("src1"), {intVal := 5}); |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(vl_content == {intVal := 5}) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerAggregatedStat_mean_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of aggregated stats |
| // as data source to another aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerAggregatedStat_mean_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "mean_src1", |
| c_EPTF_StatHandler_Method_Mean, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "mean_src2", |
| c_EPTF_StatHandler_Method_Mean, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "mean_target", |
| c_EPTF_StatHandler_Method_Mean, |
| {floatVal := 0.0}); |
| |
| var EPTF_FloatList src1 := {1.0, 2.0, 3.0}; |
| f_EPTF_Var_newVar("src1.mean", {floatVal := f_StatHandler_Test_getMean(src1)}); |
| f_EPTF_Var_newVar("src1.nofSamples", {intVal := sizeof(src1)}); |
| f_EPTF_StatHandlerClient_registerStat_Mean( |
| "src1.mean", |
| "src1.nofSamples", |
| "mean_src1"); |
| |
| var EPTF_FloatList src2 := {4.0, 5.0}; |
| f_EPTF_Var_newVar("src2.mean", {floatVal := f_StatHandler_Test_getMean(src2)}); |
| f_EPTF_Var_newVar("src2.nofSamples", {intVal := sizeof(src2)}); |
| f_EPTF_StatHandlerClient_registerStat_Mean( |
| "src2.mean", |
| "src2.nofSamples", |
| "mean_src2"); |
| |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "mean_src1", |
| "mean_target"); |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "mean_src2", |
| "mean_target"); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("mean_target"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(f_StatHandler_Test_checkFloatVarContentEquality(vl_content, f_StatHandler_Test_getMean(src1&src2))) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerAggregatedStat_standardDev_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of aggregated stats |
| // as data source to another aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerAggregatedStat_standardDev_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "standardDev_src1", |
| c_EPTF_StatHandler_Method_StandardDev, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "standardDev_src2", |
| c_EPTF_StatHandler_Method_StandardDev, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "standardDev_target", |
| c_EPTF_StatHandler_Method_StandardDev, |
| {floatVal := 0.0}); |
| |
| var EPTF_FloatList src1 := {1.0, 2.0, 3.0}; |
| f_EPTF_Var_newVar("src1.mean", {floatVal := f_StatHandler_Test_getMean(src1)}); |
| f_EPTF_Var_newVar("src1.nofSamples", {intVal := sizeof(src1)}); |
| f_EPTF_Var_newVar("src1.S", {floatVal := f_EPTF_StatHandler_Test_getStandardDev_S(src1)}); |
| f_EPTF_StatHandlerClient_registerStat_StandardDev( |
| "src1.mean", |
| "src1.nofSamples", |
| "src1.S", |
| "standardDev_src1"); |
| |
| var EPTF_FloatList src2 := {4.0, 5.0}; |
| f_EPTF_Var_newVar("src2.mean", {floatVal := f_StatHandler_Test_getMean(src2)}); |
| f_EPTF_Var_newVar("src2.nofSamples", {intVal := sizeof(src2)}); |
| f_EPTF_Var_newVar("src2.S", {floatVal := f_EPTF_StatHandler_Test_getStandardDev_S(src2)}); |
| f_EPTF_StatHandlerClient_registerStat_StandardDev( |
| "src2.mean", |
| "src2.nofSamples", |
| "src2.S", |
| "standardDev_src2"); |
| |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "standardDev_src1", |
| "standardDev_target"); |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "standardDev_src2", |
| "standardDev_target"); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("standardDev_target"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(f_StatHandler_Test_checkFloatVarContentEquality(vl_content, f_EPTF_StatHandler_Test_getStandardDev_S(src1&src2))) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerAggregatedStat_globalAverage_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of aggregated stats |
| // as data source to another aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerAggregatedStat_globalAverage_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "globalAverage_src1", |
| c_EPTF_StatHandler_Method_GlobalAverage, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "globalAverage_src2", |
| c_EPTF_StatHandler_Method_GlobalAverage, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "globalAverage_target", |
| c_EPTF_StatHandler_Method_GlobalAverage, |
| {floatVal := 0.0}); |
| |
| var EPTF_FloatList src1 := {1.0, 2.0, 3.0}; |
| f_EPTF_Var_newVar("src1.sum", {floatVal := 6.0}); |
| f_EPTF_Var_newVar("src1.elementNumber", {intVal := 3}); |
| f_EPTF_StatHandlerClient_registerStat_GlobalAverage( |
| "src1.sum", |
| "src1.elementNumber", |
| "globalAverage_src1"); |
| |
| var EPTF_FloatList src2 := {4.0, 5.0}; |
| f_EPTF_Var_newVar("src2.sum", {floatVal := 9.0}); |
| f_EPTF_Var_newVar("src2.elementNumber", {intVal := 2}); |
| f_EPTF_StatHandlerClient_registerStat_GlobalAverage( |
| "src2.sum", |
| "src2.elementNumber", |
| "globalAverage_src2"); |
| |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "globalAverage_src1", |
| "globalAverage_target"); |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "globalAverage_src2", |
| "globalAverage_target"); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("globalAverage_target"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(f_StatHandler_Test_checkFloatVarContentEquality(vl_content, 3.0)) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerAggregatedStat_density_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of aggregated stats |
| // as data source to another aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerAggregatedStat_density_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "density_src1", |
| c_EPTF_StatHandler_Method_Density, |
| {integerlistVal := {0,0,0,0,0}}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "density_src2", |
| c_EPTF_StatHandler_Method_Density, |
| {integerlistVal := {0,0,0,0,0}}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "density_target", |
| c_EPTF_StatHandler_Method_Density, |
| {integerlistVal := {0,0,0,0,0}}); |
| |
| f_EPTF_Var_newVar("src1.density", {integerlistVal := {0,1,2,3,4}}); |
| f_EPTF_Var_newVar("src1.boundaries", {floatlistVal := {0.0,0.1,0.2,0.3}}); |
| f_EPTF_StatHandlerClient_registerStat_Density( |
| "src1.density", |
| "src1.boundaries", |
| "density_src1"); |
| |
| f_EPTF_Var_newVar("src2.density", {integerlistVal := {4,3,2,1,0}}); |
| f_EPTF_Var_newVar("src2.boundaries", {floatlistVal := {0.0,0.1,0.2,0.3}}); |
| f_EPTF_StatHandlerClient_registerStat_Density( |
| "src2.density", |
| "src2.boundaries", |
| "density_src2"); |
| |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "density_src1", |
| "density_target"); |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "density_src2", |
| "density_target"); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("density_target"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(vl_content == {integerlistVal := {4,4,4,4,4}}) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerAggregatedStat_percentile95_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of aggregated stats |
| // as data source to another aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerAggregatedStat_percentile95_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "percentile95_src1", |
| c_EPTF_StatHandler_Method_Percentile95, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "percentile95_src2", |
| c_EPTF_StatHandler_Method_Percentile95, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "percentile95_target", |
| c_EPTF_StatHandler_Method_Percentile95, |
| {floatVal := 0.0}); |
| |
| f_EPTF_Var_newVar("src1.density", {integerlistVal := {5,4,3,2,1}}); |
| f_EPTF_Var_newVar("src1.boundaries", {floatlistVal := {0.0,0.1,0.2,0.3}}); |
| f_EPTF_Var_newVar("src1.max", {floatVal := 0.35}); |
| f_EPTF_StatHandlerClient_registerStat_Percentile95( |
| "src1.density", |
| "src1.boundaries", |
| "src1.max", |
| "percentile95_src1"); |
| |
| f_EPTF_Var_newVar("src2.density", {integerlistVal := {1,2000,3,4,5}}); |
| f_EPTF_Var_newVar("src2.boundaries", {floatlistVal := {0.0,0.1,0.2,0.3}}); |
| f_EPTF_Var_newVar("src2.max", {floatVal := 0.29}); |
| f_EPTF_StatHandlerClient_registerStat_Percentile95( |
| "src2.density", |
| "src2.boundaries", |
| "src2.max", |
| "percentile95_src2"); |
| |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "percentile95_src1", |
| "percentile95_target"); |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "percentile95_src2", |
| "percentile95_target"); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("percentile95_target"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(f_StatHandler_Test_checkFloatVarContentEquality(vl_content, 0.1)) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerAggregatedStat_percentileP_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of aggregated stats |
| // as data source to another aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerAggregatedStat_percentileP_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "percentileP_src1", |
| c_EPTF_StatHandler_Method_PercentileP, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "percentileP_src2", |
| c_EPTF_StatHandler_Method_PercentileP, |
| {floatVal := 0.0}); |
| f_EPTF_StatHandlerClient_declareStat( |
| "percentileP_target", |
| c_EPTF_StatHandler_Method_PercentileP, |
| {floatVal := 0.0}); |
| |
| f_EPTF_Var_newVar("src1.density", {integerlistVal := {5,4,3,2,1}}); |
| f_EPTF_Var_newVar("src1.boundaries", {floatlistVal := {0.0,0.1,0.2,0.3}}); |
| f_EPTF_Var_newVar("src1.max", {floatVal := 0.35}); |
| f_EPTF_Var_newVar("src1.pValue", {floatVal := 0.5}); |
| f_EPTF_StatHandlerClient_registerStat_PercentileP( |
| "src1.density", |
| "src1.boundaries", |
| "src1.max", |
| "src1.pValue", |
| "percentileP_src1"); |
| |
| f_EPTF_Var_newVar("src2.density", {integerlistVal := {1,2000,3,4,5}}); |
| f_EPTF_Var_newVar("src2.boundaries", {floatlistVal := {0.0,0.1,0.2,0.3}}); |
| f_EPTF_Var_newVar("src2.max", {floatVal := 0.29}); |
| f_EPTF_Var_newVar("src2.pValue", {floatVal := 0.5}); |
| f_EPTF_StatHandlerClient_registerStat_PercentileP( |
| "src2.density", |
| "src2.boundaries", |
| "src2.max", |
| "src2.pValue", |
| "percentileP_src2"); |
| |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "percentileP_src1", |
| "percentileP_target"); |
| f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_statHandler_compRef, |
| "percentileP_src2", |
| "percentileP_target"); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("percentileP_target"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(f_StatHandler_Test_checkFloatVarContentEquality(vl_content, 0.1)) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| }// group RegisterAggregatedStat |
| |
| group RegisterMeasuredStat |
| { |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerMeasuredStat_max_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of StatMeasure stats |
| // as data source to an aggregated stat |
| // |
| // Detailed Comments: |
| // Test is for measured stats with only the statistics value. |
| // This includes the following stat types: content, delta, deltaSum, min, max, EPS, chrono, custom |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerMeasuredStat_max_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "myStat", |
| c_EPTF_StatHandler_Method_Max, |
| {intVal := 0}); |
| |
| var integer vl_var1 := f_EPTF_Var_newVar("var1", {intVal := 0}); |
| var integer vl_var2 := f_EPTF_Var_newVar("var2", {intVal := 0}); |
| |
| var integer vl_measuredStat1 := f_EPTF_StatMeasure_newStat_max(vl_var1); |
| var integer vl_measuredStat2 := f_EPTF_StatMeasure_newStat_max(vl_var2); |
| |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat1, "myStat"); |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat2, "myStat"); |
| |
| f_EPTF_Var_adjustContent(vl_var1, {intVal := 3}); |
| f_EPTF_Var_adjustContent(vl_var2, {intVal := 9}); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("myStat"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(vl_content == {intVal := 9}) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerMeasuredStat_mean_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of StatMeasure stats |
| // as data source to an aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerMeasuredStat_mean_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "myStat", |
| c_EPTF_StatHandler_Method_Mean, |
| {floatVal := 0.0}); |
| |
| var integer vl_var1 := f_EPTF_Var_newVar("var1", {floatVal := 1.0}); |
| var integer vl_var2 := f_EPTF_Var_newVar("var2", {floatVal := 4.0}); |
| |
| var integer vl_measuredStat1 := f_EPTF_StatMeasure_newStat_mean(vl_var1); |
| var integer vl_measuredStat2 := f_EPTF_StatMeasure_newStat_mean(vl_var2); |
| |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat1, "myStat"); |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat2, "myStat"); |
| |
| // fix: StatMeasure was modified so it ignores the initial values of the Vars |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 1.0}); |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 4.0}); |
| // ~fix |
| |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 2.0}); |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 3.0}); |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 5.0}); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("myStat"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(f_StatHandler_Test_checkFloatVarContentEquality(vl_content, f_StatHandler_Test_getMean({1.0, 2.0, 3.0, 4.0, 5.0}))) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerMeasuredStat_standardDev_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of StatMeasure stats |
| // as data source to an aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerMeasuredStat_standardDev_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "myStat", |
| c_EPTF_StatHandler_Method_StandardDev, |
| {floatVal := 0.0}); |
| |
| var integer vl_var1 := f_EPTF_Var_newVar("var1", {floatVal := 1.0}); |
| var integer vl_var2 := f_EPTF_Var_newVar("var2", {floatVal := 4.0}); |
| |
| var integer vl_measuredStat1 := f_EPTF_StatMeasure_newStat_standardDev(vl_var1); |
| var integer vl_measuredStat2 := f_EPTF_StatMeasure_newStat_standardDev(vl_var2); |
| |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat1, "myStat"); |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat2, "myStat"); |
| |
| // fix: StatMeasure was modified so it ignores the initial values of the Vars |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 1.0}); |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 4.0}); |
| // ~fix |
| |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 2.0}); |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 3.0}); |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 5.0}); |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("myStat"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(f_StatHandler_Test_checkFloatVarContentEquality(vl_content, f_EPTF_StatHandler_Test_getStandardDev_S({1.0, 2.0, 3.0, 4.0, 5.0}))) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerMeasuredStat_density_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of StatMeasure stats |
| // as data source to an aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerMeasuredStat_density_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "myStat", |
| c_EPTF_StatHandler_Method_Density, |
| {integerlistVal := {0,0,0,0,0}}); |
| |
| var integer vl_var1 := f_EPTF_Var_newVar("var1", {floatVal := 0.0}); |
| var integer vl_var2 := f_EPTF_Var_newVar("var2", {floatVal := 0.0}); |
| |
| var EPTF_FloatList vl_boundaries := {1.0,2.0,3.0,4.0}; |
| |
| var integer vl_measuredStat1 := f_EPTF_StatMeasure_newStat_density(vl_boundaries, vl_var1); |
| var integer vl_measuredStat2 := f_EPTF_StatMeasure_newStat_density(vl_boundaries, vl_var2); |
| |
| // fix: StatMeasure was modified so it ignores the initial values of the Vars |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 0.0}); |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 0.0}); |
| // ~fix |
| |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat1, "myStat"); |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat2, "myStat"); |
| |
| var integer i; |
| for(i:=0;i<29;i:=i+1) { |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 1.5}); |
| } |
| for(i:=0;i<5;i:=i+1) { |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 3.5}); |
| } |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("myStat"); |
| |
| timer T; |
| T.start(2.0 * tsp_EPTF_Var_SyncInterval); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| if(vl_content == {integerlistVal := {2,29,0,5,0}}) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerMeasuredStat_percentile95_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of StatMeasure stats |
| // as data source to an aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerMeasuredStat_percentile95_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "myStat", |
| c_EPTF_StatHandler_Method_Percentile95, |
| {floatVal := 0.0}); |
| |
| var integer vl_var1 := f_EPTF_Var_newVar("var1", {floatVal := 0.0}); |
| var integer vl_var2 := f_EPTF_Var_newVar("var2", {floatVal := 0.0}); |
| var integer vl_var3 := f_EPTF_Var_newVar("var3", {floatVal := 0.0}); |
| |
| var EPTF_FloatList vl_boundaries := {1.0,2.0,3.0,4.0}; |
| |
| var integer vl_measuredStat1 := f_EPTF_StatMeasure_newStat_percentile95(vl_boundaries, vl_var1); |
| var integer vl_measuredStat2 := f_EPTF_StatMeasure_newStat_percentile95(vl_boundaries, vl_var2); |
| var integer vl_measuredStat3 := f_EPTF_StatMeasure_newStat_percentile95(vl_boundaries, vl_var3); |
| |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat1, "myStat"); |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat2, "myStat"); |
| |
| var integer i; |
| for(i:=0;i<29;i:=i+1) { |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 1.5}); |
| f_EPTF_Var_adjustContent(vl_var3, {floatVal := 1.5}); |
| } |
| for(i:=0;i<12;i:=i+1) { |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 2.5}); |
| f_EPTF_Var_adjustContent(vl_var3, {floatVal := 2.5}); |
| } |
| for(i:=0;i<2;i:=i+1) { |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 3.5}); |
| f_EPTF_Var_adjustContent(vl_var3, {floatVal := 3.5}); |
| } |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("myStat"); |
| |
| timer T; |
| T.start(2.0 * (tsp_EPTF_Var_SyncInterval + tsp_EPTF_Var_refreshSubscribersPeriod)); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| var float vl_statVal := 0.0; |
| f_EPTF_StatMeasure_getStat_percentile95(vl_measuredStat1, vl_statVal); |
| log("Measured stat #1: ", vl_statVal); |
| f_EPTF_StatMeasure_getStat_percentile95(vl_measuredStat2, vl_statVal); |
| log("Measured stat #2: ", vl_statVal); |
| |
| f_EPTF_StatMeasure_getStat_percentile95(vl_measuredStat3, vl_statVal); |
| log("Measured stat total: ", vl_statVal); |
| |
| if(f_StatHandler_Test_checkFloatVarContentEquality(vl_content, vl_statVal)) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| //f_EPTF_Base_wait4Shutdown(); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_StatHandler_Test_registerMeasuredStat_percentileP_client |
| // |
| // Purpose: |
| // Client behavior function for testing registration of StatMeasure stats |
| // as data source to an aggregated stat |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| function f_StatHandler_Test_registerMeasuredStat_percentileP_client(in EPTF_StatHandler_CT pl_statHandler_compRef) |
| runs on EPTF_StatHandlerClient_CT |
| { |
| f_EPTF_StatHandlerClient_init_CT("client", pl_statHandler_compRef); |
| f_EPTF_StatHandlerClient_declareStat( |
| "myStat", |
| c_EPTF_StatHandler_Method_PercentileP, |
| {floatVal := 0.0}); |
| |
| var integer vl_var1 := f_EPTF_Var_newVar("var1", {floatVal := 0.0}); |
| var integer vl_var2 := f_EPTF_Var_newVar("var2", {floatVal := 0.0}); |
| var integer vl_var3 := f_EPTF_Var_newVar("var3", {floatVal := 0.0}); |
| |
| var EPTF_FloatList vl_boundaries := {1.0,2.0,3.0,4.0}; |
| |
| var integer vl_measuredStat1 := f_EPTF_StatMeasure_newStat_percentileP(vl_boundaries, 0.5, vl_var1); |
| var integer vl_measuredStat2 := f_EPTF_StatMeasure_newStat_percentileP(vl_boundaries, 0.5, vl_var2); |
| var integer vl_measuredStat3 := f_EPTF_StatMeasure_newStat_percentileP(vl_boundaries, 0.5, vl_var3); |
| |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat1, "myStat"); |
| f_EPTF_StatHandlerClient_registerStatOfStatMeasure(vl_measuredStat2, "myStat"); |
| |
| var integer i; |
| for(i:=0;i<29;i:=i+1) { |
| f_EPTF_Var_adjustContent(vl_var1, {floatVal := 1.5}); |
| f_EPTF_Var_adjustContent(vl_var3, {floatVal := 1.5}); |
| } |
| for(i:=0;i<12;i:=i+1) { |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 2.5}); |
| f_EPTF_Var_adjustContent(vl_var3, {floatVal := 2.5}); |
| } |
| for(i:=0;i<2;i:=i+1) { |
| f_EPTF_Var_adjustContent(vl_var2, {floatVal := 3.5}); |
| f_EPTF_Var_adjustContent(vl_var3, {floatVal := 3.5}); |
| } |
| |
| var charstring vl_statVar := f_EPTF_StatHandlerClient_getStatVariableRef("myStat"); |
| |
| timer T; |
| T.start(2.0 * (tsp_EPTF_Var_SyncInterval + tsp_EPTF_Var_refreshSubscribersPeriod)); |
| T.timeout; |
| |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getRemoteContent(pl_statHandler_compRef, vl_statVar, vl_content); |
| |
| log("target stat contains ", vl_content); |
| |
| var float vl_statVal := 0.0; |
| f_EPTF_StatMeasure_getStat_percentileP(vl_measuredStat1, vl_statVal); |
| log("Measured stat #1: ", vl_statVal); |
| f_EPTF_StatMeasure_getStat_percentileP(vl_measuredStat2, vl_statVal); |
| log("Measured stat #2: ", vl_statVal); |
| |
| f_EPTF_StatMeasure_getStat_percentileP(vl_measuredStat3, vl_statVal); |
| log("Measured stat total: ", vl_statVal); |
| |
| if(f_StatHandler_Test_checkFloatVarContentEquality(vl_content, vl_statVal)) { |
| setverdict(pass); |
| } else { |
| setverdict(fail); |
| } |
| // f_EPTF_Base_wait4Shutdown(); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| } // group RegisterMeasuredStat |
| |
| }//group RegressionTest |
| |
| }//module |
