///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Copyright (c) 2000-2019 Ericsson Telecom AB                               //
//                                                                           //
// All rights reserved. This program and the accompanying materials          //
// are made available under the terms of the Eclipse Public License v2.0     //
// which accompanies this distribution, and is available at                  //
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html                                 //
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
//  Module: EPTF_ExecCtrl_PullModel_PerfTest_Functions
// 
//  Purpose:
//    This module contains the Functions to test pull model performance.
// 
//  Module depends on:
//   <EPTF_ExecCtrl_Test_Definitions>
//   <EPTF_ExecCtrl_Test_Function>
//   <EPTF_CLL_Base_Functions>           
//   <EPTF_CLL_Common_Definitions>
//   <EPTF_CLL_CLI_Definitions>
//   <EPTF_CLL_ExecCtrlTimeProfile_Definitions>
//   <EPTF_CLL_ExecCtrl_Functions>
//   <EPTF_CLL_ExecCtrl_CLIFunctions>
//   <EPTF_CLL_ExecCtrl_Definitions>
//   <EPTF_CLL_UIHandler_WidgetFunctions>
//   <EPTF_CLL_ExecCtrlUIHandler_Definitions>
//   <EPTF_CLL_HashMapInt2Int_Functions>
//   <EPTF_CLL_HashMapOct2Int_Functions>
//   <EPTF_CLL_HashMapStr2Int_Functions>
// 
//  Current Owner:
//    Jozsef Gyurusi (ETHJGI)
// 
//  Last Review Date:
//    2013-xx-xx
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////

module EPTF_ExecCtrl_PullModel_PerfTest_Functions {

import from EPTF_ExecCtrl_PullModel_PerfTest_Definitions all;

import from EPTF_CLL_ExecCtrl_Definitions all;
import from EPTF_CLL_LGenBase_ConfigFunctions all;
import from EPTF_CLL_LGenBase_Functions all;
import from EPTF_CLL_ExecCtrlClient_Functions all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_LoadRegulator_Functions all;
import from EPTF_CLL_LoadRegulator_Definitions all;
import from EPTF_CLL_Variable_Definitions all;
import from EPTF_CLL_LGenBase_ConfigDefinitions all;
import from EPTF_CLL_ExecCtrl_Functions all;
import from EPTF_CLL_DataSource_Functions all;
import from EPTF_CLL_ExecCtrl_CLIFunctions all;
import from EPTF_CLL_HostAdmin_BaseFunctions all;
import from EPTF_CLL_StatMeasure_Functions all;

import from EPTF_CLL_UIHandler_XULFunctions all;
import from EPTF_CLL_UIHandler_WidgetFunctions all;
import from ttcn_ericsson_se_protocolModules_xtdp_xtdl all;
import from ttcn_ericsson_se_TitanSim_Perftest all;
import from EPTF_CLL_Common_Definitions all;
import from TestResultGen all;

function f_EPTF_ExecCtrl_Test_DataSourceClientReady(
  in charstring pl_source,
  in charstring pl_ptcName)
runs on myMTC_UI{
  if (pl_source==c_ExecCtrl_DataSource_sourceId) {
    v_ready := true;
  }
}

  function f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviourWithFSMStatsLive(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSMWithFSMStatsLive);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_PullModel_PerfTest_createDefaultLGenWithSpecIdWithFSMStatsLive  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on ExecCtrlDSClient_Test_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviourWithFSMStatsLive("ExecCtrl_DefaultLGen_"&log2str(v_lgenId),self) );
    v_lgenId := v_lgenId + 1;
    return vl_lgen;
  }

  function f_EPTF_ExecCtrl_Test_PhaseRegulator_getSutLoad()
  runs on EPTF_LoadRegulator_CT
  return float
  {
    return 1.0;
  }

  function f_EPTF_ExecCtrl_Test_PhaseRegulator_calcCPS(in float loadToReach, in float oldCps)
  runs on PhaseRegulator_CT
  return float
  {
    return loadToReach;
  }

  function f_EPTF_ExecCtrl_Test_PhaseRegulator_behavior(
    in charstring pl_selfName,
    in EPTF_Var_CT pl_execCtrlCompRef,
    in float pl_loadToReach)
  runs on PhaseRegulator_CT
  {
    f_EPTF_LoadRegulator_init_CT(pl_selfName,
      refers(f_EPTF_ExecCtrl_Test_PhaseRegulator_getSutLoad),
      refers(f_EPTF_ExecCtrl_Test_PhaseRegulator_calcCPS));
    f_EPTF_LoadRegulator_registerToExecCtrl(pl_execCtrlCompRef);
    f_EPTF_LoadRegulator_adjustTargetLoadInExecCtrl(pl_loadToReach);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Regulator_Test_RegulatorBehaviour(
    in charstring pl_selfName,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef,
    in float pl_loadToReach := 0.0
  ) runs on EPTF_LoadRegulator_CT {
    f_EPTF_LoadRegulator_init_CT(pl_selfName,
      refers(f_EPTF_ExecCtrl_Test_PhaseRegulator_getSutLoad),
      refers(f_EPTF_LoadRegulator_calculateNextCps_limitMax));
    f_EPTF_LoadRegulator_registerToExecCtrl(pl_execCtrlCompRef);
    f_EPTF_LoadRegulator_adjustTargetLoadInExecCtrl(pl_loadToReach);
    f_EPTF_Base_wait4Shutdown();
  }


function f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_main(
  in integer pl_nofExternalStatHandlers := 0,
  in boolean pl_usePullModeForStats := false
) runs on ExecCtrl_NewGUITest_CT {

  // create lot of egrps:
  var EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList vl_EPTF_ExecCtrl_EGrpList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList;
  // create lof of egrp->sc assignments:
  var EPTF_LGenBase_TcMgmt_Scenarios2GrpList vl_EPTF_ExecCtrl_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList;
  // add all egrps to LgenPool:
  var EPTF_ExecCtrl_EntityGroup2LGenPool_List vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List := c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List;
  for(var integer i :=1; i<tsp_EPTF_ExecCtrl_PullModel_PerfTest_nofEGrps; i:=i+1) {
    vl_EPTF_ExecCtrl_EGrpList := vl_EPTF_ExecCtrl_EGrpList&{vl_EPTF_ExecCtrl_EGrpList[0]};
    vl_EPTF_ExecCtrl_EGrpList[i].name := vl_EPTF_ExecCtrl_EGrpList[i].name & int2str(i);
    
    vl_EPTF_ExecCtrl_Scenarios2GrpList := vl_EPTF_ExecCtrl_Scenarios2GrpList&{vl_EPTF_ExecCtrl_Scenarios2GrpList[0]};
    vl_EPTF_ExecCtrl_Scenarios2GrpList[2*i].eGrpName := vl_EPTF_ExecCtrl_Scenarios2GrpList[2*i].eGrpName  & int2str(i);
    vl_EPTF_ExecCtrl_Scenarios2GrpList := vl_EPTF_ExecCtrl_Scenarios2GrpList&{vl_EPTF_ExecCtrl_Scenarios2GrpList[1]};
    vl_EPTF_ExecCtrl_Scenarios2GrpList[2*i+1].eGrpName := vl_EPTF_ExecCtrl_Scenarios2GrpList[2*i+1].eGrpName  & int2str(i);
    vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List := vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List&{vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List[0]};

    vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List[i].eGrpName := vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List[i].eGrpName&int2str(i);
  }
  
  // set CPS to 1.0:
  var float vl_targetCPS := 1.0;
  var EPTF_LGenBase_ScenarioTypeDeclarator vl_EPTF_ExecCtrl_normalScenario := c_EPTF_ExecCtrl_DefaultScenarios_normalScenario;
  vl_EPTF_ExecCtrl_normalScenario.tcList[0].tcParamsList[3].target.cpsToReach := vl_targetCPS;
  vl_EPTF_ExecCtrl_normalScenario.tcList[1].tcParamsList[3].target.cpsToReach := vl_targetCPS;
  var EPTF_LGenBase_ScenarioTypeDeclarator vl_EPTF_ExecCtrl_weightedScenario := c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario;
  vl_EPTF_ExecCtrl_weightedScenario.scParamsList[0].weightedScData.cpsToReach := vl_targetCPS;
  var EPTF_LGenBase_ScenarioTypeDeclarator vl_EPTF_ExecCtrl_normalScenarioInScGrp := c_EPTF_ExecCtrl_DefaultScenarios_normalScenarioInScGrp;
  vl_EPTF_ExecCtrl_normalScenarioInScGrp.tcList[0].tcParamsList[3].target.cpsToReach := vl_targetCPS;
  vl_EPTF_ExecCtrl_normalScenarioInScGrp.tcList[1].tcParamsList[3].target.cpsToReach := vl_targetCPS;
  var EPTF_LGenBase_ScenarioTypeDeclarator vl_EPTF_ExecCtrl_weightedScenarioInScGrp := c_EPTF_ExecCtrl_DefaultScenarios_weightedScenarioInScGrp;
  vl_EPTF_ExecCtrl_weightedScenarioInScGrp.scParamsList[0].weightedScData.cpsToReach := vl_targetCPS;

  var EPTF_ExecCtrl_LGenPool_Declarators vl_EPTF_ExecCtrl_lgenPoolDeclarators := c_EPTF_ExecCtrl_Test_defaultLGenPoolWithSpecId_DeclaratorsWithFSMStatsLive;
  vl_EPTF_ExecCtrl_lgenPoolDeclarators[0].lgenPoolItems[0].num := tsp_EPTF_ExecCtrl_PullModel_PerfTest_nofLgens;
  
  f_EPTF_ExecCtrl_loadConfig(
    pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := vl_EPTF_ExecCtrl_EGrpList,
    pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := vl_EPTF_ExecCtrl_Scenarios2GrpList&
    c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList_scGroups,
    pl_EPTF_LGenBase_ScenarioDeclaratorList := {},
    pl_EPTF_LGenBase_tcTypeDeclaratorList := {},
    pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType},
    pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList := {},
    pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList:= {},
    pl_EPTF_ExecCtrl_TimeProfileDescrList:={},
    pl_EPTF_ExecCtrl_TimeProfileList:={},
    pl_EPTF_ExecCtrl_TimeProfile2TcList:={},
    pl_EPTF_LGenBase_ScenarioTypeDeclaratorList:= {
      vl_EPTF_ExecCtrl_normalScenario,vl_EPTF_ExecCtrl_weightedScenario,
      vl_EPTF_ExecCtrl_normalScenarioInScGrp,vl_EPTF_ExecCtrl_weightedScenarioInScGrp
    },
    pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
    pl_EPTF_ExecCtrl_LGenPool_Declarators:=vl_EPTF_ExecCtrl_lgenPoolDeclarators,
    pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List,
    pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{
        name := omit,
        fn := refers(f_ExecCtrl_PullModel_PerfTest_createDefaultLGenWithSpecIdWithFSMStatsLive)
      }},
    pl_EPTF_ExecCtrl_PhaseList_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_phases,
    pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_scGroups,
    pl_EPTF_ExecCtrl_RegulatorNames:={},
    pl_EPTF_ExecCtrl_RegulatedItems:={}
  );
  f_EPTF_ExecCtrl_setManualControl(true);

  f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_ExecCtrl_Test_DataSourceClientReady ));
  f_EPTF_ExecCtrl_CLI_init_CT(
    pl_selfName := "ExecCtrl",
    pl_nrOfClients := 0,
    pl_createLGenPools := true,
    pl_CLI_compRef := mtc,
    pl_loadModulepars := true,
    pl_autoStart := true,
    pl_dataSource_compRef := mtc,
    pl_nofExternalStatHandlers := pl_nofExternalStatHandlers,
    pl_usePullModeForStats := pl_usePullModeForStats
  );

}
function f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_execCtrlBehaviour(
  in integer pl_nofExternalStatHandlers := 0,
  in boolean pl_usePullModeForStats := false
) runs on ExecCtrl_NewGUITest_CT {
  f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_main(pl_nofExternalStatHandlers,pl_usePullModeForStats);
  f_EPTF_Base_wait4Shutdown();
}


function f_EPTF_ExecCtrl_Test_checkReadyToRun() runs on ExecCtrl_NewGUITest_CT return boolean {  
  var EPTF_Var_DirectContent vl_value;
  f_EPTF_DataSource_getDataValue(
      pl_dataValue := vl_value,
      pl_source := "ExecCtrl",
      pl_ptcName := "",
      pl_element := "ReadyToRun",
      pl_params := {}
  );
  return vl_value == {statusLEDVal := {led_green, "ReadyToRun"}};
}

altstep as_EPTF_ExecCtrl_Test_measureCPU() runs on ExecCtrl_PullModelPerfTest_CT {
  [] t_cpuMeasure.timeout {
    f_EPTF_HostAdmin_Base_update();
    
    var float vl_cpuLoad := f_EPTF_HostAdmin_Base_getProcessCpuLoad(v_execCtrlPID);
    f_EPTF_StatMeasure_addData_standardDev(v_execCtrlCPULoadStat,vl_cpuLoad);
    //action("**** ExecCtrlCPULoad: ", vl_cpuLoad);
    var float vl_memUsage := int2float(f_EPTF_HostAdmin_Base_getProcessMemUsage(v_execCtrlPID));
    f_EPTF_StatMeasure_addData_standardDev(v_execCtrlMemUsageStat,vl_memUsage);
    //action("**** ExecCtrlMemUsage: ", vl_memUsage);
    
    vl_cpuLoad := f_EPTF_HostAdmin_Base_getProcessCpuLoad(v_uiHandlerPID);
    f_EPTF_StatMeasure_addData_standardDev(v_uiHandlerCPULoadStat,vl_cpuLoad);
    //action("**** UIHandlerCPULoad: ", vl_cpuLoad);
    vl_memUsage := int2float(f_EPTF_HostAdmin_Base_getProcessMemUsage(v_uiHandlerPID));
    f_EPTF_StatMeasure_addData_standardDev(v_uiHandlerMemUsageStat,vl_memUsage);
    //action("**** UIHandlerMemUsage: ", vl_memUsage);


    vl_cpuLoad := f_EPTF_HostAdmin_Base_getTesterHostLoad();
    f_EPTF_StatMeasure_addData_standardDev(v_hostCPULoadStat,vl_cpuLoad);
    //action("**** HostCPULoad: ", vl_cpuLoad);
    vl_memUsage := int2float(f_EPTF_HostAdmin_Base_getFreeMemory());
    f_EPTF_StatMeasure_addData_standardDev(v_hostFreeMemoryStat,vl_memUsage);
    //action("**** HostMemUsage: ", vl_memUsage);

    t_cpuMeasure.start;    
    repeat;
  }
}

function f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_mainTestCase(
  in integer pl_nofExternalStatHandlers := 0,
  in boolean pl_usePullModeForStats := false
) runs on ExecCtrl_PullModelPerfTest_CT
{

  var integer vl_startNumOfEGrps := tsp_EPTF_ExecCtrl_PullModel_PerfTest_nofEGrps; //Number of egrps
  var integer vl_lGenNum         := tsp_EPTF_ExecCtrl_PullModel_PerfTest_nofLgens; // Number of LGens
  var float vl_maxStartUpTime    := tsp_EPTF_ExecCtrl_PullModel_PerfTest_maxStartUpTime;
  
  var Testresult vl_testResult;
  vl_testResult.name := "ExecCtrl Pull Model Measurement";
  vl_testResult.purpose := "To measure CPU load on ExecCtrl and StatHandlers when pull model is used";
  f_TestResultGen_getEnvironment(vl_testResult.environment);
  vl_testResult.parameter_list := {
    {name := "Number of EntityGroups", unit := "-", base := log2str(vl_startNumOfEGrps) },
    {name := "Number of LGens", unit := "-", base := log2str(vl_lGenNum) },
    {name := "nofExternalStatHandlers", unit := "-", base := log2str(pl_nofExternalStatHandlers) },
    {name := "pullModelEnabled", unit := "-", base := log2str(pl_usePullModeForStats) },
    {name := "maxStartUpTime", unit := "sec", base := log2str(vl_maxStartUpTime) },
    {name := "EPTF_DEBUG", unit := "-", base := log2str(c_EPTF_Common_debugSwitch) }
  };
  vl_testResult.result_list := {};
  // var charstring vl_startTime := f_getTimeFormatted(f_time(), "%c");
  var charstring vl_start_time := f_TestResultGen_getCurrentTime();
  vl_testResult.start_time := vl_start_time;

  var float vl_startTimeSystem := f_EPTF_Base_getRelTimeInSecs();

  var charstring vl_wndLayout := c_EPTF_ExecCtrl_Test_defaultMainWindow_str;
  f_EPTF_UIHandlerXUL_init_CT("UIHandler", true, vl_wndLayout,self);
  f_EPTF_HostAdmin_Base_init_CT(f_EPTF_Base_selfName());
  f_EPTF_DataSource_init_CT(f_EPTF_Base_selfName());
  f_EPTF_StatMeasure_init_CT(f_EPTF_Base_selfName());
  v_execCtrlCPULoadStat := f_EPTF_StatMeasure_newStat_standardDev();
  v_execCtrlMemUsageStat := f_EPTF_StatMeasure_newStat_standardDev();
  v_uiHandlerCPULoadStat := f_EPTF_StatMeasure_newStat_standardDev();
  v_uiHandlerMemUsageStat := f_EPTF_StatMeasure_newStat_standardDev();
  
  v_hostCPULoadStat := f_EPTF_StatMeasure_newStat_standardDev();
  v_hostFreeMemoryStat := f_EPTF_StatMeasure_newStat_standardDev();


  //initial free mem an CPU load on host:
  var float vl_cpuLoad, vl_freeMem;
  f_EPTF_HostAdmin_Base_update();
  vl_cpuLoad := f_EPTF_HostAdmin_Base_getTesterHostLoad();
  f_EPTF_StatMeasure_addData_standardDev(v_hostCPULoadStat,vl_cpuLoad);
  vl_freeMem := int2float(f_EPTF_HostAdmin_Base_getFreeMemory());
  f_EPTF_StatMeasure_addData_standardDev(v_hostFreeMemoryStat,vl_freeMem);
  f_EPTF_HostAdmin_Base_update();
  vl_cpuLoad := f_EPTF_HostAdmin_Base_getTesterHostLoad();
  f_EPTF_StatMeasure_addData_standardDev(v_hostCPULoadStat,vl_cpuLoad);
  vl_freeMem := int2float(f_EPTF_HostAdmin_Base_getFreeMemory());
  f_EPTF_StatMeasure_addData_standardDev(v_hostFreeMemoryStat,vl_freeMem);

  var float vl_avgHostCPULoad, vl_stdDevHostCPULoad;
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostCPULoadStat,vl_avgHostCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_hostCPULoadStat,vl_stdDevHostCPULoad);
  action("**** Host avg cpu initial: ", vl_avgHostCPULoad);
  action("**** Host stdev cpu initial: ", vl_stdDevHostCPULoad);
   vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "Host initial CPU load",
      unit := "sec",
      base := log2str(vl_avgHostCPULoad)&"+-"&log2str(vl_stdDevHostCPULoad)
    }
  };
  var float vl_avgHostFreeMemory, vl_stdDevHostFreeMemory;
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostFreeMemoryStat,vl_avgHostFreeMemory);
  f_EPTF_StatMeasure_getStat_standardDev(v_hostFreeMemoryStat,vl_stdDevHostFreeMemory);
  action("**** Host avg FreeMem initial: ", vl_avgHostFreeMemory);
  action("**** Host stdev FreeMem initial: ", vl_stdDevHostFreeMemory);
   vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "Host initial FreeMem",
      unit := "kB",
      base := log2str(float2int(vl_avgHostFreeMemory))&"+-"&log2str(vl_stdDevHostFreeMemory)
    }
  };
  f_EPTF_StatMeasure_resetStat_standardDev(v_hostCPULoadStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_hostFreeMemoryStat);

  timer t_wait := 0.0, t_maxWait := 5.0;
  var charstring vl_dataVarName;
  t_maxWait.start;
  t_wait.start;
  alt {
    [0==f_EPTF_DataSource_checkData(
      pl_dataVarName := vl_dataVarName,
      pl_source := "UIHandler",
      pl_ptcName := "",
      pl_element := "progressBar",
      pl_params := {}
    )] t_wait.timeout; // wait for UIHander DS registration
    [] t_maxWait.timeout {
      setverdict(fail,"Cannot display progress information, UIHandler DS registration timed out");
      //f_EPTF_Base_stop(none);
    }
  }

//   f_EPTF_UIHandler_createGUI("
//     <Widgets xmlns='http://ttcn.ericsson.se/protocolModules/xtdp/xtdl'>
//       <hbox flex='0.0' id='' orientation='horizontal'>
//       <label flex='0.0' value='Progress:' />
//       <spacer flex='0.0' />
//       <textbox id='ProgressBar' flex='1.0' readonly='true' value=''>
//         <externaldata element='progressBar' source='UIHandler'>
//           <params>
//           </params>
//         </externaldata>
//       </textbox>
//       </hbox>
//     </Widgets>",
//     "EPTF_Main_Window"
//   );

  action("**** Starting ExecCtrl...");
  f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_ExecCtrl_Test_DataSourceClientReady ));
  
  var float vl_startTimeExecCtrl := f_EPTF_Base_getRelTimeInSecs();
  var ExecCtrl_NewGUITest_CT vl_execCtrl := ExecCtrl_NewGUITest_CT.create;
  vl_execCtrl.start(f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_execCtrlBehaviour(pl_nofExternalStatHandlers,pl_usePullModeForStats));
  //var ExecCtrl_NewGUITest_CT vl_execCtrl := self;
  //f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_main();

 // start the regulators:
  var PhaseRegulator_CT vl_regulator1 := PhaseRegulator_CT.create;
  vl_regulator1.start(f_EPTF_ExecCtrl_Test_PhaseRegulator_behavior("Regulator 1",vl_execCtrl,1.0));
  var EPTF_LoadRegulator_CT vl_regulator2 := EPTF_LoadRegulator_CT.create;
  vl_regulator2.start(f_ExecCtrl_Regulator_Test_RegulatorBehaviour("Regulator 3",vl_execCtrl,1.0));

  t_wait.start(2.0);
  t_wait.timeout;
  v_execCtrlPID := f_EPTF_Base_getPidByName("ExecCtrl");
  v_uiHandlerPID := f_EPTF_Base_getPidByName("UIHandler");
  activate(as_EPTF_ExecCtrl_Test_measureCPU());
  action("**** All component info: ",f_EPTF_Base_getComponentInfoAll());
  action("**** ExecCtrl Pid: ", v_execCtrlPID);
  action("**** UIHandler Pid: ", v_uiHandlerPID);
  f_EPTF_HostAdmin_Base_addProcessStat(v_execCtrlPID);
  f_EPTF_HostAdmin_Base_addProcessStat(v_uiHandlerPID);

  timer T_guard, T_alt;
  T_guard.start( vl_maxStartUpTime );
  T_alt.start( 0.0 );
  alt{
    [] T_guard.timeout{
      setverdict(fail,"Timeout during config");
      //      f_EPTF_Base_stopAll();
    }
    [v_ready and f_EPTF_ExecCtrl_Test_checkReadyToRun()] T_alt.timeout{}
  };
  //  f_EPTF_ExecCtrl_startAllScenarios();
  //log(%definitionId&"--bubu-----------------------------------"&f_EPTF_UIHandler_snapshot())
  //f_EPTF_UIHandler_clearGUI(); //gui.xml contains window => should start with empty gui

  var float vl_endTimeExecCtrl := f_EPTF_Base_getRelTimeInSecs();
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "ExecCtrl startup time",
      unit := "sec",
      base := log2str(vl_endTimeExecCtrl-vl_startTimeExecCtrl)
    }
  };
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "System startup time",
      unit := "sec",
      base := log2str(vl_endTimeExecCtrl-vl_startTimeSystem)
    }
  };
  action("ExecCtrl startup time: ", vl_endTimeExecCtrl-vl_startTimeExecCtrl," secs");
  action("System startup time: ", vl_endTimeExecCtrl-vl_startTimeSystem," secs");

  action("**** Building GUI...");
  t_cpuMeasure.start;
  var float vl_startTime := f_EPTF_Base_getRelTimeInSecs();
  f_EPTF_UIHandler_createGUIFromFile(tsp_ExecCtrl_DS_guiXmlName,""/*c_ExecCtrl_DS_customGUIHBox*/);
  var float vl_endTime := f_EPTF_Base_getRelTimeInSecs();
  action("GUI Build up time: ", vl_endTime-vl_startTime," secs");

  t_cpuMeasure.stop;

  vl_testResult.end_time := f_TestResultGen_getCurrentTime();
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "GUI Build up time",
      unit := "sec",
      base := log2str(vl_endTime-vl_startTime)
    }
  };
  
  var float vl_avgExecCtrlCPULoad, vl_stdDevExecCtrlCPULoad;
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlCPULoadStat,vl_avgExecCtrlCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlCPULoadStat,vl_stdDevExecCtrlCPULoad);
  action("**** ExecCtrl avg cpu createGUI: ", vl_avgExecCtrlCPULoad);
  action("**** ExecCtrl stdev cpu createGUI: ", vl_stdDevExecCtrlCPULoad);
   vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "ExecCtrl CPU load during GUI buildup",
      unit := "%",
      base := log2str(vl_avgExecCtrlCPULoad)&"+-"&log2str(vl_stdDevExecCtrlCPULoad)
    }
  };
  var float vl_avgExecCtrlMemUsage, vl_stdDevExecCtrlMemUsage;
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlMemUsageStat,vl_avgExecCtrlMemUsage);
  f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlMemUsageStat,vl_stdDevExecCtrlMemUsage);
  action("**** ExecCtrl avg MemUsage createGUI: ", vl_avgExecCtrlMemUsage);
  action("**** ExecCtrl stdev MemUsage createGUI: ", vl_stdDevExecCtrlMemUsage);
   vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "ExecCtrl MemUsage during GUI buildup",
      unit := "kB",
      base := log2str(float2int(vl_avgExecCtrlMemUsage))&"+-"&log2str(vl_stdDevExecCtrlMemUsage)
    }
  };

  var float vl_avgUIHandlerCPULoad, vl_stdDevUIHandlerCPULoad;
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerCPULoadStat,vl_avgUIHandlerCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerCPULoadStat,vl_stdDevUIHandlerCPULoad);
  action("**** UIHandler avg cpu createGUI: ", vl_avgUIHandlerCPULoad);
  action("**** UIHandler stdev cpu createGUI: ", vl_stdDevUIHandlerCPULoad);
   vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "UIHandler CPU load during GUI buildup",
      unit := "%",
      base := log2str(vl_avgUIHandlerCPULoad)&"+-"&log2str(vl_stdDevUIHandlerCPULoad)
    }
  };
  var float vl_avgUIHandlerMemUsage, vl_stdDevUIHandlerMemUsage;
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerMemUsageStat,vl_avgUIHandlerMemUsage);
  f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerMemUsageStat,vl_stdDevUIHandlerMemUsage);
  action("**** UIHandler avg MemUsage createGUI: ", vl_avgUIHandlerMemUsage);
  action("**** UIHandler stdev MemUsage createGUI: ", vl_stdDevUIHandlerMemUsage);
   vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "UIHandler MemUsage during GUI buildup",
      unit := "kB",
      base := log2str(float2int(vl_avgUIHandlerMemUsage))&"+-"&log2str(vl_stdDevUIHandlerMemUsage)
    }
  };

  f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostCPULoadStat,vl_avgHostCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_hostCPULoadStat,vl_stdDevHostCPULoad);
  action("**** Host avg cpu createGUI: ", vl_avgHostCPULoad);
  action("**** Host stdev cpu createGUI: ", vl_stdDevHostCPULoad);
   vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "Host CPU load during GUI buildup",
      unit := "%",
      base := log2str(vl_avgHostCPULoad)&"+-"&log2str(vl_stdDevHostCPULoad)
    }
  };
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostFreeMemoryStat,vl_avgHostFreeMemory);
  f_EPTF_StatMeasure_getStat_standardDev(v_hostFreeMemoryStat,vl_stdDevHostFreeMemory);
  action("**** Host avg FreeMem createGUI: ", vl_avgHostFreeMemory);
  action("**** Host stdev FreeMem createGUI: ", vl_stdDevHostFreeMemory);
   vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "Host FreeMem during GUI buildup",
      unit := "kB",
      base := log2str(float2int(vl_avgHostFreeMemory))&"+-"&log2str(vl_stdDevHostFreeMemory)
    }
  };

  // wait until subscribe finishes (UIHandler load decreases below 10):
  action("*** Waiting for UIHandler to be idle");
  vl_startTime := f_EPTF_Base_getRelTimeInSecs();
  f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerCPULoadStat);
  t_cpuMeasure.start;
  timer T_measurePeriod := 10.0;
  T_measurePeriod.start
  alt {
    [] T_measurePeriod.timeout {
      f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerCPULoadStat,vl_avgUIHandlerCPULoad);
      if (vl_avgUIHandlerCPULoad>10.0) {
        T_measurePeriod.start
        f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerCPULoadStat);
        repeat;
      }
    }
  }
  t_cpuMeasure.stop;
  vl_endTime := f_EPTF_Base_getRelTimeInSecs();
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "UIHandler time to idle",
      unit := "sec",
      base := log2str(vl_endTime-vl_startTime)
    }
  };
  action("*** UIHandler is idle");
 
 // measure Idle state CPU:
  f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlCPULoadStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlMemUsageStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerCPULoadStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerMemUsageStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_hostCPULoadStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_hostFreeMemoryStat);


  t_cpuMeasure.start;
  
  timer T_g2;
  T_g2.start( 10.0 ); // idle gen measure time
  T_g2.timeout;
  t_cpuMeasure.stop;

  f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlCPULoadStat,vl_avgExecCtrlCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlCPULoadStat,vl_stdDevExecCtrlCPULoad);
  action("**** ExecCtrl avg cpu idle: ", vl_avgExecCtrlCPULoad);
  action("**** ExecCtrl stdev cpu idle: ", vl_stdDevExecCtrlCPULoad);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "ExecCtrl idle CPU load",
      unit := "%",
      base := log2str(vl_avgExecCtrlCPULoad)&"+-"&log2str(vl_stdDevExecCtrlCPULoad)
    }
  };
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlMemUsageStat,vl_avgExecCtrlMemUsage);
  f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlMemUsageStat,vl_stdDevExecCtrlMemUsage);
  action("**** ExecCtrl avg MemUsage idle: ", vl_avgExecCtrlMemUsage);
  action("**** ExecCtrl stdev MemUsage idle: ", vl_stdDevExecCtrlMemUsage);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "ExecCtrl idle MemUsage",
      unit := "kB",
      base := log2str(float2int(vl_avgExecCtrlMemUsage))&"+-"&log2str(vl_stdDevExecCtrlMemUsage)
    }
  };

  f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerCPULoadStat,vl_avgUIHandlerCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerCPULoadStat,vl_stdDevUIHandlerCPULoad);
  action("**** UIHandler avg cpu idle: ", vl_avgUIHandlerCPULoad);
  action("**** UIHandler stdev cpu idle: ", vl_stdDevUIHandlerCPULoad);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "UIHandler idle CPU load",
      unit := "%",
      base := log2str(vl_avgUIHandlerCPULoad)&"+-"&log2str(vl_stdDevUIHandlerCPULoad)
    }
  };
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerMemUsageStat,vl_avgUIHandlerMemUsage);
  f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerMemUsageStat,vl_stdDevUIHandlerMemUsage);
  action("**** UIHandler avg MemUsage idle: ", vl_avgUIHandlerMemUsage);
  action("**** UIHandler stdev MemUsage idle: ", vl_stdDevUIHandlerMemUsage);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "UIHandler idle MemUsage",
      unit := "kB",
      base := log2str(float2int(vl_avgUIHandlerMemUsage))&"+-"&log2str(vl_stdDevUIHandlerMemUsage)
    }
  };

  f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostCPULoadStat,vl_avgHostCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_hostCPULoadStat,vl_stdDevHostCPULoad);
  action("**** Host avg cpu idle: ", vl_avgHostCPULoad);
  action("**** Host stdev cpu idle: ", vl_stdDevHostCPULoad);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "Host idle CPU load",
      unit := "%",
      base := log2str(vl_avgHostCPULoad)&"+-"&log2str(vl_stdDevHostCPULoad)
    }
  };
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostFreeMemoryStat,vl_avgHostFreeMemory);
  f_EPTF_StatMeasure_getStat_standardDev(v_hostFreeMemoryStat,vl_stdDevHostFreeMemory);
  action("**** Host avg FreeMem idle: ", vl_avgHostFreeMemory);
  action("**** Host stdev FreeMem idle: ", vl_stdDevHostFreeMemory);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "Host idle FreeMem",
      unit := "kB",
      base := log2str(float2int(vl_avgHostFreeMemory))&"+-"&log2str(vl_stdDevHostFreeMemory)
    }
  };

  action("**** Starting load generation...");
  
  // measure CPU load during load generation:
  f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlCPULoadStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlMemUsageStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerCPULoadStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerMemUsageStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_hostCPULoadStat);
  f_EPTF_StatMeasure_resetStat_standardDev(v_hostFreeMemoryStat);
  
  var EPTF_Var_DirectContent vl_dataValue := {intVal := 1};
  f_EPTF_DataSource_setDataValue(
    pl_dataValue := vl_dataValue,
    pl_source := c_ExecCtrl_DataSource_sourceId,
    pl_ptcName := "",
    pl_element := c_ExecCtrl_dataElementStart,
    pl_params := {}
  )

  t_cpuMeasure.start;
  T_g2.start( 60.0 ); // load gen gen measure time
  T_g2.timeout;
  t_cpuMeasure.stop;

  f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlCPULoadStat,vl_avgExecCtrlCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlCPULoadStat,vl_stdDevExecCtrlCPULoad);
  action("**** ExecCtrl avg cpu during loadGen: ", vl_avgExecCtrlCPULoad);
  action("**** ExecCtrl stdev cpu during loadGen: ", vl_stdDevExecCtrlCPULoad);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "ExecCtrl CPU load during load generation",
      unit := "%",
      base := log2str(vl_avgExecCtrlCPULoad)&"+-"&log2str(vl_stdDevExecCtrlCPULoad)
    }
  };
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlMemUsageStat,vl_avgExecCtrlMemUsage);
  f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlMemUsageStat,vl_stdDevExecCtrlMemUsage);
  action("**** ExecCtrl avg MemUsage during loadGen: ", vl_avgExecCtrlMemUsage);
  action("**** ExecCtrl stdev MemUsage during loadGen: ", vl_stdDevExecCtrlMemUsage);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "ExecCtrl MemUsage during load generation",
      unit := "kB",
      base := log2str(float2int(vl_avgExecCtrlMemUsage))&"+-"&log2str(vl_stdDevExecCtrlMemUsage)
    }
  };
  

  f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerCPULoadStat,vl_avgUIHandlerCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerCPULoadStat,vl_stdDevUIHandlerCPULoad);
  action("**** UIHandler avg cpu during loadGen: ", vl_avgUIHandlerCPULoad);
  action("**** UIHandler stdev cpu during loadGen: ", vl_stdDevUIHandlerCPULoad);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "UIHandler CPU load during load generation",
      unit := "%",
      base := log2str(vl_avgUIHandlerCPULoad)&"+-"&log2str(vl_stdDevUIHandlerCPULoad)
    }
  };
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerMemUsageStat,vl_avgUIHandlerMemUsage);
  f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerMemUsageStat,vl_stdDevUIHandlerMemUsage);
  action("**** UIHandler avg MemUsage during loadGen: ", vl_avgUIHandlerMemUsage);
  action("**** UIHandler stdev MemUsage during loadGen: ", vl_stdDevUIHandlerMemUsage);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "UIHandler MemUsage during load generation",
      unit := "kB",
      base := log2str(float2int(vl_avgUIHandlerMemUsage))&"+-"&log2str(vl_stdDevUIHandlerMemUsage)
    }
  };

  f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostCPULoadStat,vl_avgHostCPULoad);
  f_EPTF_StatMeasure_getStat_standardDev(v_hostCPULoadStat,vl_stdDevHostCPULoad);
  action("**** Host avg cpu during loadGen: ", vl_avgHostCPULoad);
  action("**** Host stdev cpu during loadGen: ", vl_stdDevHostCPULoad);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "Host CPU load during load generation",
      unit := "%",
      base := log2str(vl_avgHostCPULoad)&"+-"&log2str(vl_stdDevHostCPULoad)
    }
  };
  f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostFreeMemoryStat,vl_avgHostFreeMemory);
  f_EPTF_StatMeasure_getStat_standardDev(v_hostFreeMemoryStat,vl_stdDevHostFreeMemory);
  action("**** Host avg FreeMem during loadGen: ", vl_avgHostFreeMemory);
  action("**** Host stdev FreeMem during loadGen: ", vl_stdDevHostFreeMemory);
  vl_testResult.result_list := vl_testResult.result_list & {
    {
      name := "Host FreeMem during load generation",
      unit := "kB",
      base := log2str(float2int(vl_avgHostFreeMemory))&"+-"&log2str(vl_stdDevHostFreeMemory)
    }
  };

  vl_testResult.end_time := f_TestResultGen_getCurrentTime();
  f_TestResultGen_appendResult("ExecCtrl_PullModel_PerfTest_"&vl_start_time&".xml", vl_testResult);

}


} //end of module EPTF_ExecCtrl_PullModel_PerfTest_Functions