test/StatMeasure/EPTF_StatMeasure_Test_Testcases.ttcn

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// 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_StatMeasure_Test_Testcases {

import from EPTF_CLL_StatMeasure_Definitions 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_CLL_Base_Functions all;
import from EPTF_CLL_Common_Definitions all; // EPTF_IntegerList
import from EPTF_StatMeasure_Test_Definitions all;
import from EPTF_StatMeasure_Test_Functions all;

group BasicTest {
///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_complex
  //
  //  Purpose:
  //   To test most of functionalites in one testcase
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for int, float variable and for standalone stat.
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in more steps and checks the stat value with more methods
  //
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  testcase tc_EPTF_StatMeasure_Test_complex() runs on EPTF_StatMeasure_Test_CT {

    f_EPTF_Var_CT_LogAll("----- START -------");
    f_EPTF_StatMeasure_init_CT("StatMeasure_test");
    f_EPTF_Var_CT_LogAll("----- INIT READY -------");

    f_createConfig();

    // register stats:
    var EPTF_IntegerList vl_statListFor_intVar;
    var EPTF_IntegerList vl_statListFor_floatVar;
    var EPTF_IntegerList vl_statListFor_noVar;

    vl_statListFor_intVar:=f_EPTF_StatMeasure_createAllStats(v_intVarIdx);
    vl_statListFor_floatVar:=f_EPTF_StatMeasure_createAllStats(v_floatVarIdx);
    vl_statListFor_noVar:=f_EPTF_StatMeasure_createAllStats(-1);

    // create var for stat:
    log("vl_statListFor_intVar: ", vl_statListFor_intVar);
    var EPTF_IntegerList vl_noVar_statIdxList;
    for (var integer i:=0; i<sizeof(vl_statListFor_intVar); i:=i+1) {
      log("i: ",i);
      vl_noVar_statIdxList[i] := f_EPTF_StatMeasure_createVarFromStat(vl_statListFor_intVar[i]);

      // if density: set boundaries to linear scale:
      if (f_EPTF_StatMeasure_getStatType(vl_statListFor_intVar[i]) == density) {
        log("DENSITY");
        f_EPTF_StatMeasure_setScale_density(vl_statListFor_intVar[i],0.0,10.0,11);
        f_EPTF_StatMeasure_setScale_density(vl_statListFor_floatVar[i],0.0,10.0,11);
      }

      // if density: set boundaries to linear scale:
      if (f_EPTF_StatMeasure_getStatType(vl_statListFor_intVar[i]) == percentile95) {
        log("PERCENTILE");
        f_EPTF_StatMeasure_setScale_percentile95(vl_statListFor_intVar[i],0.0,10.0,6);
        f_EPTF_StatMeasure_setScale_percentile95(vl_statListFor_floatVar[i],0.0,10.0,6);
      }
    }

    f_EPTF_Var_CT_LogAll("----- REGISTER STATS -------");
    f_EPTF_StatMeasure_LogAll("----- REGISTER STATS -------");   

    // REFRESH
    f_EPTF_Var_refreshContent(v_intVarIdx);

    // ADJUST local.REF.param
    f_EPTF_Var_adjustContent(v_floatVarIdx,{floatVal:=6.0});

    f_EPTF_Var_adjustContent(v_intVarIdx,{intVal:=10});
    f_EPTF_Var_adjustContent(v_floatVarIdx,{floatVal:=8.0});

    f_EPTF_Var_CT_LogAll("----- ADJUST VARS -------");
    f_EPTF_StatMeasure_LogAll("----- ADJUST VARS -------");   

    f_EPTF_StatMeasure_resetStats(vl_statListFor_floatVar);
    f_EPTF_Var_CT_LogAll("----- RESET STATS FOR " & int2str(v_floatVarIdx) & " -------");

    // ADJUST 
    f_EPTF_Var_adjustContent(v_floatVarIdx,{floatVal:=1.0});
    f_EPTF_Var_adjustContent(v_floatVarIdx,{floatVal:=2.0});
    f_EPTF_Var_adjustContent(v_floatVarIdx,{floatVal:=3.0});
    f_EPTF_Var_adjustContent(v_floatVarIdx,{floatVal:=4.0});
    f_EPTF_Var_adjustContent(v_floatVarIdx,{floatVal:=5.0});
    f_EPTF_Var_CT_LogAll("----- ADJUST FLOAT -------");
    f_EPTF_StatMeasure_LogAll("----- ADJUST FLOAT -------");    


    // NO VAR
    f_EPTF_StatMeasure_addData_delta(vl_statListFor_noVar[1],{intVal := 1});
    f_EPTF_StatMeasure_addData_delta(vl_statListFor_noVar[1],{intVal := 2});
    f_EPTF_StatMeasure_addData_delta(vl_statListFor_noVar[1],{intVal := 6});
    f_EPTF_StatMeasure_addData_delta(vl_statListFor_noVar[1],{intVal := 7});

    f_EPTF_StatMeasure_addData_deltaSum(vl_statListFor_noVar[2],{intVal := 1});
    f_EPTF_StatMeasure_addData_deltaSum(vl_statListFor_noVar[2],{intVal := 2});
    f_EPTF_StatMeasure_addData_deltaSum(vl_statListFor_noVar[2],{intVal := 6});
    f_EPTF_StatMeasure_addData_deltaSum(vl_statListFor_noVar[2],{intVal := 7});

    f_EPTF_StatMeasure_addData_min(vl_statListFor_noVar[3],{intVal := 1});
    f_EPTF_StatMeasure_addData_min(vl_statListFor_noVar[3],{intVal := 2});
    f_EPTF_StatMeasure_addData_min(vl_statListFor_noVar[3],{intVal := 6});
    f_EPTF_StatMeasure_addData_min(vl_statListFor_noVar[3],{intVal := 7});

    f_EPTF_StatMeasure_addData_max(vl_statListFor_noVar[4],{intVal := 1});
    f_EPTF_StatMeasure_addData_max(vl_statListFor_noVar[4],{intVal := 2});
    f_EPTF_StatMeasure_addData_max(vl_statListFor_noVar[4],{intVal := 6});
    f_EPTF_StatMeasure_addData_max(vl_statListFor_noVar[4],{intVal := 7});

    f_EPTF_StatMeasure_addData_mean(vl_statListFor_noVar[5],1.0);
    f_EPTF_StatMeasure_addData_mean(vl_statListFor_noVar[5],2.0);
    f_EPTF_StatMeasure_addData_mean(vl_statListFor_noVar[5],6.0);
    f_EPTF_StatMeasure_addData_mean(vl_statListFor_noVar[5],7.0);

    f_EPTF_StatMeasure_addData_standardDev(vl_statListFor_noVar[6],1.0);
    f_EPTF_StatMeasure_addData_standardDev(vl_statListFor_noVar[6],2.0);
    f_EPTF_StatMeasure_addData_standardDev(vl_statListFor_noVar[6],6.0);
    f_EPTF_StatMeasure_addData_standardDev(vl_statListFor_noVar[6],7.0);

    f_EPTF_StatMeasure_addData_EPS(vl_statListFor_noVar[7]);
    f_EPTF_StatMeasure_addData_EPS(vl_statListFor_noVar[7]);
    f_EPTF_StatMeasure_addData_EPS(vl_statListFor_noVar[7]);
    f_EPTF_StatMeasure_addData_EPS(vl_statListFor_noVar[7]);
    f_EPTF_StatMeasure_update_EPS(vl_statListFor_noVar[7],2.0);

    f_EPTF_StatMeasure_addData_chrono(vl_statListFor_noVar[8]);
    f_EPTF_StatMeasure_addData_chrono(vl_statListFor_noVar[8]);
    f_EPTF_StatMeasure_addData_chrono(vl_statListFor_noVar[8]);
    f_EPTF_StatMeasure_addData_chrono(vl_statListFor_noVar[8]);
    f_EPTF_StatMeasure_update_chrono(vl_statListFor_noVar[8]);

    f_EPTF_StatMeasure_setScale_density(vl_statListFor_noVar[9],0.0,10.0,11);
    f_EPTF_StatMeasure_addData_density(vl_statListFor_noVar[9],1.0);
    f_EPTF_StatMeasure_addData_density(vl_statListFor_noVar[9],2.0);
    f_EPTF_StatMeasure_addData_density(vl_statListFor_noVar[9],6.0);
    f_EPTF_StatMeasure_addData_density(vl_statListFor_noVar[9],7.0);

    f_EPTF_Var_CT_LogAll("----- ADDDATA NOVAR -------");
    f_EPTF_StatMeasure_LogAll("----- ADDDATA NOVAR -------");

    f_EPTF_StatMeasure_LogAll("STATLIST");
    log("EXPECTED: ", t_expectedResult);
    log("MATCH: ", match(f_EPTF_StatMeasure_statList(), t_expectedResult));
    f_setverdictFail(not match(f_EPTF_StatMeasure_statList(), t_expectedResult));  

    //log("Bad one: SL / EXP: ", statList[27].statData.percentile95.pos, " / ", 
    //  valueof(t_expectedResult[27].statData.percentile95.pos));
    //f_DEBUG_float(statList[27].statData.percentile95.pos);
    //f_DEBUG_float(valueof(t_expectedResult[27].statData.percentile95.pos));  

    // SAMPLEDAVERAGE:

    // create a new EPS stat without a variable:
    var integer vl_EPSIdx := f_EPTF_StatMeasure_newStat_EPS();

    var float vl_sampleTime := 0.5; // the period of the calculation of the EPSs (CPS)
    timer t_sample := vl_sampleTime;
    timer t_refresh := 0.11;
    timer t_end := 10.0;
    t_sample.start; t_refresh.start; t_end.start;

    alt {
      [] t_end.timeout {
          f_EPTF_StatMeasure_LogAll("----- PeriodicUPDATESAMPLEDAVERAGE STATS END-------");
        }
      [] t_refresh.timeout {
          t_refresh.start;

          f_EPTF_StatMeasure_addData_EPS(vl_EPSIdx); //(new call is generated)
          log(t_end.read, ":  EPS");
          //f_EPTF_Var_adjustContent(v_intVarIdx,{intVal:=5}); // also: adjust the variable, but do not change the value        
          repeat;
        }
      [] t_sample.timeout {
          t_sample.start;

          f_EPTF_StatMeasure_update_EPS(vl_EPSIdx,vl_sampleTime);
          f_EPTF_StatMeasure_update_EPS(vl_statListFor_floatVar[7],vl_sampleTime);
          f_EPTF_StatMeasure_LogAll("----- PeriodicUPDATE_SAMPLEDAVERAGE STATS -------");        
          repeat;
        }
    }

    // END

    f_EPTF_StatMeasure_update_EPS(vl_EPSIdx, 10.0);
    f_EPTF_StatMeasure_update_EPS(vl_statListFor_floatVar[7], 10.0);
    //f_EPTF_StatMeasure_LogAll("----- UPDATE_SAMPLEDAVERAGE STATS -------");

    var float vl_statValue;
    var boolean vl_isAvail;
    vl_isAvail := f_EPTF_StatMeasure_getStat_EPS(vl_EPSIdx, vl_statValue);
    log("Stat value: ", vl_statValue);
    //f_setverdictFail(vl_statValue != 8.9 or not vl_isAvail); // FIXME: depends on machine
    vl_isAvail := f_EPTF_StatMeasure_getStat_EPS(vl_statListFor_floatVar[7],vl_statValue);
    f_setverdictFail(vl_statValue!=0.5 or not vl_isAvail);

    t_wait.start;
    alt {
      [] t_wait.timeout {
          f_EPTF_Var_CT_LogAll("----- TIMEOUT -------");
        } 
    }

    f_EPTF_Var_CT_LogAll("----- LOCAL PROVIDER REMOVED -------");
    for (var integer i:=0; i<sizeof(vl_noVar_statIdxList); i:=i+1) {
      var EPTF_Var_DirectContent vl_content;
      
      if(vl_noVar_statIdxList[i]==-1) { continue; }
      
      f_EPTF_Var_getContent(vl_noVar_statIdxList[i], vl_content);
      f_EPTF_Var_Log("Value of Var ", vl_noVar_statIdxList[i]);
      log(": ", vl_content);
    }
    //f_EPTF_StatMeasure_LogAll("----- END -------");


    f_EPTF_Base_cleanup_CT();

    setverdict(pass);
  }

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_custom
  //
  //  Purpose:
  //    To test the custom statistics
  //
  //  Requirement:
  //    -
///////////////////////////////////////////////////////////

  testcase tc_EPTF_StatMeasure_Test_custom() 
  runs on EPTF_StatMeasure_Test_CT 
  {
    //f_EPTF_Var_CT_LogAll("----- START -------");
    f_EPTF_StatMeasure_init_CT("StatMeasure_test");
    //f_EPTF_Var_CT_LogAll("----- INIT READY -------");

    f_test_custom();
    
    f_EPTF_Base_cleanup_CT();

    setverdict(pass);
  }
  
///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_percentile95
  //
  //  Purpose:
  //    To test the percentile95 statistics
  //
  //  Requirement:
  //    -  
///////////////////////////////////////////////////////////  

  testcase tc_EPTF_StatMeasure_Test_percentile95() 
  runs on EPTF_StatMeasure_Test_CT 
  {
    f_EPTF_Var_CT_LogAll("----- START -------");
    f_EPTF_StatMeasure_init_CT("StatMeasure_test");
    f_EPTF_Var_CT_LogAll("----- INIT READY -------");

    f_test_percentile95(); 
    
    f_EPTF_Base_cleanup_CT();

    setverdict(pass);
  }
  
///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_percentileP
  //
  //  Purpose:
  //    To test the percentileP statistics with value P=50.0 (median)
  //
  //  Requirement:
  //    -  
///////////////////////////////////////////////////////////  

  testcase tc_EPTF_StatMeasure_Test_percentileP() 
  runs on EPTF_StatMeasure_Test_CT 
  {
    f_EPTF_Var_CT_LogAll("----- START -------");
    f_EPTF_StatMeasure_init_CT("StatMeasure_test");
    f_EPTF_Var_CT_LogAll("----- INIT READY -------");

    f_test_percentileP(); 
    
    f_EPTF_Base_cleanup_CT();

    setverdict(pass);
  }  

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_percentile95_initStatValue
  //
  //  Purpose:
  //    To test the percentile95 statistics if the initStatValue and enableStat
  //    functions work correctly
  //
  //  Requirement:
  //    -  
///////////////////////////////////////////////////////////  
testcase tc_EPTF_StatMeasure_Test_percentile95_initStatValue() runs on EPTF_StatMeasure_Test_CT{
  const EPTF_StatMeasure_StatParams c_stat95Params := {
    percentile95 := {
      scale := {
        min := 0.0,
        max := int2float(100)/10.0,
        n := 100+1,
        scale := linear}
    }
  }
  var EPTF_FloatList v_statCreateValues := {
    0.099675,
    0.199499,
    0.299061,
    0.398686,
    0.498403,
    0.598069,
    0.697334,
    0.798480,
    0.897211,
    0.997006,
    1.096776,
    1.202991,
    1.295482,
    1.395387,
    1.494898,
    1.597026,
    1.694203,
    1.793992,
    1.893537,
    1.993306,
    2.093023,
    2.192675,
    2.292374,
    2.396055,
    2.495626,
    2.594797,
    2.691148,
    2.790835,
    2.902498,
    3.001158,
    3.101910,
    3.201614,
    3.301221,
    3.400967,
    3.500654,
    3.600412,
    3.698792,
    3.799753,
    3.899419,
    3.999157,
    4.098854,
    4.198511,
    4.298232,
    4.397897,
    4.497665,
    4.601351,
    4.696895,
    4.796681,
    4.900425,
    4.994718,
    5.095780,
    5.195479,
    5.296658,
    5.397852,
    5.494582,
    5.599330,
    5.698981,
    5.797056,
    5.896068,
    5.998124,
    6.097802,
    6.198735,
    6.301152,
    6.400931,
    6.496582,
    6.600216,
    6.695966,
    6.795645,
    6.895751,
    6.995405,
    7.094930,
    7.195240,
    7.295339,
    7.394539,
    7.493431,
    7.593014,
    7.692628,
    7.800875,
    7.900030,
    8.003850,
    8.099600,
    8.203113,
    8.302629,
    8.402406,
    8.498252,
    8.597829,
    8.697564,
    8.797235,
    8.896907,
    9.000631,
    9.096147,
    9.196008,
    9.304461,
    9.395399,
    9.499011,
    9.598700,
    9.698376,
    9.794131,
    9.897755,
    9.997417
  }
  var integer vl_testVar
  f_EPTF_Var_newFloat("testVar", 0.0, vl_testVar)
  var integer vl_testStatId := f_EPTF_StatMeasure_newStatWithParams(vl_testVar, c_stat95Params)
  for ( var integer vl_i := 0; vl_i < sizeof(v_statCreateValues) ; vl_i := vl_i+1 ){
    f_EPTF_Var_adjustContent(vl_testVar, {floatVal := v_statCreateValues[vl_i]})
  }
  var float vl_expected, vl_second, vl_third
  f_EPTF_StatMeasure_getStat_percentile95(vl_testStatId, vl_expected)
  f_EPTF_StatMeasure_disableStat(vl_testStatId)
  //Set variable to 0.0
  f_EPTF_Var_adjustContent(vl_testVar, {floatVal := 0.0})
  f_EPTF_StatMeasure_initStatValue(vl_testStatId)
  f_EPTF_StatMeasure_enableStat(vl_testStatId)
  for ( var integer vl_i := 0; vl_i < sizeof(v_statCreateValues) ; vl_i := vl_i+1 ){
    f_EPTF_Var_adjustContent(vl_testVar, {floatVal := v_statCreateValues[vl_i]})
  }
  f_EPTF_StatMeasure_getStat_percentile95(vl_testStatId, vl_second)
  f_EPTF_StatMeasure_disableStat(vl_testStatId)
  //Not set variable to 0.0
  f_EPTF_StatMeasure_initStatValue(vl_testStatId)
  f_EPTF_StatMeasure_enableStat(vl_testStatId)
  for ( var integer vl_i := 0; vl_i < sizeof(v_statCreateValues) ; vl_i := vl_i+1 ){
    f_EPTF_Var_adjustContent(vl_testVar, {floatVal := v_statCreateValues[vl_i]})
  }
  f_EPTF_StatMeasure_getStat_percentile95(vl_testStatId, vl_third)
  action(vl_expected," ==? ",vl_second," ==? ",vl_third)
  if(vl_expected == vl_second and vl_third == vl_second){
    setverdict ( pass )
  }else{
    setverdict ( fail, log2str(vl_expected," ==? ",vl_second," ==? ",vl_third))
  }
}

 

 
}//group BasicTest

//*************************************************************************
//   Group FunctionTest/RegressionTest
//*************************************************************************
group FunctionTest {

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_initAndCleanup
  //
  //  Purpose:
  //    To test the functions  f_EPTF_StatMeasure_init_CT and f_EPTF_StatMeasure_cleanup_CT
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function
  //    2.   Check if all its variables are initialized
  //    2. Calls the cleanup function f_EPTF_Base_cleanup_CT()
  //    3. Checks if the cleanup function f_EPTF_StatMeasure_cleanup_CT has been called i.e the 
  //    variable v_EPTF_StatMeasure_initialized has been changed to false;
  //
  //  Expected Result: The tc is passed if checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready
  testcase tc_EPTF_StatMeasure_Test_initAndCleanup() runs on EPTF_StatMeasure_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_init_CT("StatMeasure_test");
    f_setverdictFail( v_EPTF_StatMeasure_initialized!=true);

    f_EPTF_Base_cleanup_CT();
    f_setverdictFail(v_EPTF_StatMeasure_initialized!=false);
  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_selftest
  //
  //  Purpose:
  //    To test the test component itself
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. The steps are:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT
  //    2. Checks if the flag variables v_EPTF_StatMeasure_initialized and v_EPTF_StatMeasure_Test_initialized were true
  //    3. call f_EPTF_Base_cleanup_CT to cleanup all component
  //    4. Checks if the flag variables v_EPTF_StatMeasure_initialized and v_EPTF_StatMeasure_Test_initialized were false
  //
  //  Expected Result: The tc is passed if all checks are passed
  //
///////////////////////////////////////////////////////////
  //Status: Ready
  testcase tc_EPTF_StatMeasure_Test_selftest() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    f_setverdictFail(v_EPTF_StatMeasure_Test_initialized!=true);
    //f_setverdictFail(v_EPTF_StatMeasure_initialized!=true);

    f_EPTF_Base_cleanup_CT();
    //f_setverdictFail(v_EPTF_StatMeasure_initialized!=false);
    f_setverdictFail(v_EPTF_StatMeasure_Test_initialized!=false);
  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_newStat_int
  //
  //  Purpose:
  //    To test the function f_EPTF_StatMeasure_newStat, f_EPTF_StatMeasure_getStatType
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the integer variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //  Expected Result: The tc is passed if all checks were true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_newStat_int() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_IntegerList vl_statListFor_intVar;
    log("c_EPTF_StatMeasure_Test_statTypes:",c_EPTF_StatMeasure_Test_statTypes);
    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    for(var integer i:=0; i<sizeof(c_EPTF_StatMeasure_Test_statTypes);i:=i+1) {
      vl_statListFor_intVar[i]:= f_EPTF_StatMeasure_newStat(v_intVarIdx, c_EPTF_StatMeasure_Test_statTypes[i]);
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_intVar[i]));
      f_setverdictFail( f_EPTF_StatMeasure_getVarIdx(vl_statListFor_intVar[i])!=v_intVarIdx);
    }
    //f_EPTF_StatMeasure_LogAll("===After NewStat===");
    f_EPTF_Base_cleanup_CT();
  }//tc_
///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_newStat_Type_int
  //
  //  Purpose:
  //    To test the functions 
  //      f_EPTF_StatMeasure_newStat_content
  //      f_EPTF_StatMeasure_newStat_delta
  //      f_EPTF_StatMeasure_newStat_deltaSum
  //      f_EPTF_StatMeasure_newStat_min
  //      f_EPTF_StatMeasure_newStat_max
  //      f_EPTF_StatMeasure_newStat_mean
  //      f_EPTF_StatMeasure_newStat_standardDev
  //      f_EPTF_StatMeasure_newStat_EPS
  //      f_EPTF_StatMeasure_newStat_chrono
  //      f_EPTF_StatMeasure_newStat_density
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the integer variable
  //    3. Checks if the stats exist and if their type and VarIdx is the ordered.
  //  Expected Result: The tc is passed if all checks were true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_newStat_Type_int() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_IntegerList vl_statListFor_intVar;
    log("c_EPTF_StatMeasure_Test_statTypes:",c_EPTF_StatMeasure_Test_statTypes);
    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    vl_statListFor_intVar[0]:= f_EPTF_StatMeasure_newStat_content(v_intVarIdx);
    vl_statListFor_intVar[1]:= f_EPTF_StatMeasure_newStat_delta(v_intVarIdx);
    vl_statListFor_intVar[2]:= f_EPTF_StatMeasure_newStat_deltaSum(v_intVarIdx);
    vl_statListFor_intVar[3]:= f_EPTF_StatMeasure_newStat_min(v_intVarIdx);
    vl_statListFor_intVar[4]:= f_EPTF_StatMeasure_newStat_max(v_intVarIdx);
    vl_statListFor_intVar[5]:= f_EPTF_StatMeasure_newStat_mean(v_intVarIdx);
    vl_statListFor_intVar[6]:= f_EPTF_StatMeasure_newStat_standardDev(v_intVarIdx);
    vl_statListFor_intVar[7]:= f_EPTF_StatMeasure_newStat_EPS(v_intVarIdx);
    vl_statListFor_intVar[8]:= f_EPTF_StatMeasure_newStat_chrono(v_intVarIdx);
    vl_statListFor_intVar[9]:= f_EPTF_StatMeasure_newStat_density({1.0,2.0,3.0,4.0},v_intVarIdx);

    for(var integer i:=0; i<sizeof(c_EPTF_StatMeasure_Test_statTypes);i:=i+1) {
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_intVar[i]));
      f_setverdictFail( f_EPTF_StatMeasure_getVarIdx(vl_statListFor_intVar[i])!=v_intVarIdx);
    }
    //f_EPTF_StatMeasure_LogAll("===After NewStat===");
    f_EPTF_Base_cleanup_CT();
  }//tc_
///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_newStat_float
  //
  //  Purpose:
  //    To test the functions f_EPTF_StatMeasure_newStat,f_EPTF_StatMeasure_getStatType
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats exist and if their type and VarIdx is the ordered.
  //  Expected Result: The tc is passed if all checks were true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_newStat_float() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_IntegerList vl_statListFor_floatVar;
    log("c_EPTF_StatMeasure_Test_statTypes:",c_EPTF_StatMeasure_Test_statTypes);
    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    for(var integer i:=0; i<sizeof(c_EPTF_StatMeasure_Test_statTypes);i:=i+1) {
      vl_statListFor_floatVar[i]:= f_EPTF_StatMeasure_newStat(v_floatVarIdx, c_EPTF_StatMeasure_Test_statTypes[i]);
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_floatVar[i]));
      f_setverdictFail( f_EPTF_StatMeasure_getVarIdx(vl_statListFor_floatVar[i])!=v_floatVarIdx);
    }

    //f_EPTF_StatMeasure_LogAll("===After NewStat===");

    //f_EPTF_StatMeasure_createVarFromStat(vl_statIdx, "TestStatIntVar");

    f_EPTF_Base_cleanup_CT();
  }//tc_
///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_newStat_Type_float
  //
  //  Purpose:
  //    To test the functions
  //      f_EPTF_StatMeasure_newStat_content
  //      f_EPTF_StatMeasure_newStat_delta
  //      f_EPTF_StatMeasure_newStat_deltaSum
  //      f_EPTF_StatMeasure_newStat_min
  //      f_EPTF_StatMeasure_newStat_max
  //      f_EPTF_StatMeasure_newStat_mean
  //      f_EPTF_StatMeasure_newStat_standardDev
  //      f_EPTF_StatMeasure_newStat_EPS
  //      f_EPTF_StatMeasure_newStat_chrono
  //      f_EPTF_StatMeasure_newStat_density
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an float one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //  Expected Result: The tc is passed if all checks were true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_newStat_Type_float() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_IntegerList vl_statListFor_floatVar;
    log("c_EPTF_StatMeasure_Test_statTypes:",c_EPTF_StatMeasure_Test_statTypes);
    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    vl_statListFor_floatVar[0]:= f_EPTF_StatMeasure_newStat_content(v_floatVarIdx);
    vl_statListFor_floatVar[1]:= f_EPTF_StatMeasure_newStat_delta(v_floatVarIdx);
    vl_statListFor_floatVar[2]:= f_EPTF_StatMeasure_newStat_deltaSum(v_floatVarIdx);
    vl_statListFor_floatVar[3]:= f_EPTF_StatMeasure_newStat_min(v_floatVarIdx);
    vl_statListFor_floatVar[4]:= f_EPTF_StatMeasure_newStat_max(v_floatVarIdx);
    vl_statListFor_floatVar[5]:= f_EPTF_StatMeasure_newStat_mean(v_floatVarIdx);
    vl_statListFor_floatVar[6]:= f_EPTF_StatMeasure_newStat_standardDev(v_floatVarIdx);
    vl_statListFor_floatVar[7]:= f_EPTF_StatMeasure_newStat_EPS(v_floatVarIdx);
    vl_statListFor_floatVar[8]:= f_EPTF_StatMeasure_newStat_chrono(v_floatVarIdx);
    vl_statListFor_floatVar[9]:= f_EPTF_StatMeasure_newStat_density({1.0,2.0,3.0,4.0},v_floatVarIdx);

    for(var integer i:=0; i<sizeof(c_EPTF_StatMeasure_Test_statTypes);i:=i+1) {
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_floatVar[i]));
      f_setverdictFail( f_EPTF_StatMeasure_getVarIdx(vl_statListFor_floatVar[i])!=v_floatVarIdx);
    }
    //f_EPTF_StatMeasure_LogAll("===After NewStat===");
    f_EPTF_Base_cleanup_CT();
  }//tc
///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_newStat_noVars
  //
  //  Purpose:
  //    To test the functions f_EPTF_StatMeasure_newStat, f_EPTF_StatMeasure_getStatType for standlone statistics
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of standalone stats (except for content)
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //  Expected Result: The tc is passed if all checks were true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_newStat_noVars() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_IntegerList vl_statListFor_noVar;
    //!!!!!!!!!!!!!! Change the index from 1 for 0, if f_EPTF_StatMeasure_newStat() is reapired for content type.
    for(var integer i:=1; i<sizeof(c_EPTF_StatMeasure_Test_statTypes);i:=i+1) {
      vl_statListFor_noVar[i]:= f_EPTF_StatMeasure_newStat(-1, c_EPTF_StatMeasure_Test_statTypes[i]);
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_noVar[i]));
      f_setverdictFail( f_EPTF_StatMeasure_getVarIdx(vl_statListFor_noVar[i])!=-1);
    }
    //f_EPTF_StatMeasure_LogAll("===After NewStat===");
    //f_EPTF_StatMeasure_createVarFromStat(vl_statIdx, "TestStatIntVar");
    f_EPTF_Base_cleanup_CT();
  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_newStat_Type_noVars
  //
  //  Purpose:
  //    To test the functions f_EPTF_StatMeasure_newStat_content,
  //      f_EPTF_StatMeasure_newStat_delta, e.t.c 
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an float one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //  Expected Result: The tc is passed if all checks were true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_newStat_Type_noVars() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_IntegerList vl_statListFor_noVar;
    log("c_EPTF_StatMeasure_Test_statTypes:",c_EPTF_StatMeasure_Test_statTypes);
    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    //vl_statListFor_noVar[0]:= f_EPTF_StatMeasure_newStat_content(-1);
    vl_statListFor_noVar[1]:= f_EPTF_StatMeasure_newStat_delta(-1);
    vl_statListFor_noVar[2]:= f_EPTF_StatMeasure_newStat_deltaSum(-1);
    vl_statListFor_noVar[3]:= f_EPTF_StatMeasure_newStat_min(-1);
    vl_statListFor_noVar[4]:= f_EPTF_StatMeasure_newStat_max(-1);
    vl_statListFor_noVar[5]:= f_EPTF_StatMeasure_newStat_mean(-1);
    vl_statListFor_noVar[6]:= f_EPTF_StatMeasure_newStat_standardDev(-1);
    vl_statListFor_noVar[7]:= f_EPTF_StatMeasure_newStat_EPS(-1);
    vl_statListFor_noVar[8]:= f_EPTF_StatMeasure_newStat_chrono(-1);
    vl_statListFor_noVar[9]:= f_EPTF_StatMeasure_newStat_density({1.0,2.0,3.0,4.0},-1);

    for(var integer i:=1; i<sizeof(c_EPTF_StatMeasure_Test_statTypes);i:=i+1) {
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_noVar[i]));
      f_setverdictFail( f_EPTF_StatMeasure_getVarIdx(vl_statListFor_noVar[i])!=-1);
    }
    //f_EPTF_StatMeasure_LogAll("===After NewStat===");
    f_EPTF_Base_cleanup_CT();
  }//tc

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_createAllStats
  //
  //  Purpose:
  //    To test the functions f_EPTF_StatMeasure_createAllStats and f_EPTF_StatMeasure_getStatType, f_EPTF_StatMeasure_getVarIdx
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an integer one and a float one and checks them
  //    2. Creates all types of stats for the integer and the float variable and for the standalone case
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //  Expected Result: The tc is passed if all checks were true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_createAllStats() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_IntegerList vl_statListFor_intVar;
    var EPTF_IntegerList vl_statListFor_floatVar;
    var EPTF_IntegerList vl_statListFor_noVar;
    log("c_EPTF_StatMeasure_Test_statTypes:",c_EPTF_StatMeasure_Test_statTypes);

    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    vl_statListFor_intVar:= f_EPTF_StatMeasure_createAllStats(v_intVarIdx);
    vl_statListFor_floatVar:= f_EPTF_StatMeasure_createAllStats(v_floatVarIdx);
    vl_statListFor_noVar:= f_EPTF_StatMeasure_Test_createAllStats(-1);

    for(var integer i:=0; i<sizeof(c_EPTF_StatMeasure_Test_statTypes);i:=i+1) {
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_intVar[i]));
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_floatVar[i]));

      f_setverdictFail( f_EPTF_StatMeasure_getVarIdx(vl_statListFor_floatVar[i])!=v_floatVarIdx);
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_floatVar[i]));
      f_setverdictFail( f_EPTF_StatMeasure_getVarIdx(vl_statListFor_floatVar[i])!=v_floatVarIdx);
    }

    for(var integer i:=1; i<sizeof(c_EPTF_StatMeasure_Test_statTypes);i:=i+1) {
      vl_statListFor_noVar[i]:= f_EPTF_StatMeasure_newStat(-1, c_EPTF_StatMeasure_Test_statTypes[i]);
      f_setverdictFail( c_EPTF_StatMeasure_Test_statTypes[i]!=f_EPTF_StatMeasure_getStatType(vl_statListFor_noVar[i]));
      f_setverdictFail( f_EPTF_StatMeasure_getVarIdx(vl_statListFor_noVar[i])!=-1);
    }

    //f_EPTF_StatMeasure_LogAll("===After NewStat===");

    f_EPTF_Base_cleanup_CT();
  }//tc_

  //=============================================================================
  //===           Test of Content Type Related Functions                       ==
  //=============================================================================

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_content
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_content,
  //       - f_EPTF_StatMeasure_content2str
  //       - f_EPTF_StatMeasure_value2str for content
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates stats of type "content" for the int and float variables
  //    3. Adjust their contents by calling f_EPTF_Var_adjustContent
  //    4. Check if the statistics are the sama as the adjusted values by calling f_EPTF_StatMeasure_value2str
  //       and f_EPTF_StatMeasure_content2str
  //
  //  Expected Result: The tc is passed if all checks were true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_content() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var integer vl_statIdx_intVar;
    var integer vl_statIdx_floatVar;
    //var integer vl_statIdx_noVar;

    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_content(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_content(v_floatVarIdx);
    //vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_content(-1); //<<== not supported

    f_EPTF_StatMeasure_LogAll("===After NewStat===");
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 20 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 30.0 } )
    f_EPTF_StatMeasure_LogAll("===After Adjust===");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="20");
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="30.000000");
    f_setverdictFail( f_EPTF_StatMeasure_content2str(vl_statIdx_intVar) !="20");
    f_setverdictFail( f_EPTF_StatMeasure_content2str(vl_statIdx_floatVar)!="30.000000");

    var EPTF_Var_DirectContent vl_statValue;
    f_EPTF_StatMeasure_getStat_content(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=20});
    log( "vl_statValue :", vl_statValue);
    f_EPTF_StatMeasure_getStat_content(vl_statIdx_floatVar,vl_statValue);
    f_setverdictFail(vl_statValue!={floatVal:=30.000000});
    log( "vl_statValue :", vl_statValue);
    f_EPTF_Base_cleanup_CT();
  }//tc_

  //=============================================================================
  //===           Test of Delta Type Related Functions                       ==
  //=============================================================================

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_delta
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_delta,
  //       - f_EPTF_StatMeasure_delta2str
  //       - f_EPTF_StatMeasure_value2str for content
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Call the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Create "delta" types of stats for the int and the float variable and for the standalone stats, as well by
  //       calling f_EPTF_StatMeasure_newStat_delta
  //    3. Check if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value by more methods
  //       Uses f_EPTF_Var_adjustContent
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For standalone (noVars) statistics there is no measured Variable therefore it is not refreshed after enabled - the values added have been forgotten
  //
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_delta() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=0.001; //epsilon: limit of difference

    //Test of f_EPTF_StatMeasure_newStat_delta
    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_delta(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_delta(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_delta(-1);

    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_EPTF_Var_refreshContent(v_floatVarIdx)
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 20 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 30.0 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="10"); //20-10
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="20.000000");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="10");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_floatVar)!="20.000000");

    var EPTF_Var_DirectContent vl_statValue;
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail( vl_statValue!={intVal:=10});

    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_floatVar,vl_statValue));
    f_setverdictFail(vl_statValue!={floatVal:=20.000000});


    //Test of f_EPTF_StatMeasure_createVarFromStat
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=10});

    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_setverdictFail(vl_statValue!={floatVal:=20.0});

    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=0});

    //test if the changes are copied 
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 60 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 80.4 } )

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=60);
    f_EPTF_StatMeasure_Test_checkFloatEquality(f_EPTF_Var_getFloatValue(v_floatVarIdx),80.4, vl_eps);

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="40"); //60-20
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="40");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="50.400000"); //80.4 - 30.0
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_floatVar)!="50.400000");

    f_setverdictFail(not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=40});
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_floatVar,vl_statValue));
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,50.4, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=40} );
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,50.4, vl_eps)

    //test addData/adjustContent when enabled:
    //int
    //f_EPTF_StatMeasure_addData_delta(vl_statIdx_intVar, { intVal:= 160 });//<<== It cannot be used!!!
    f_EPTF_Var_adjustContent( v_intVarIdx, { intVal:= 160 } );

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=160);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="100"); //160-100
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="100");

    f_setverdictFail(not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=100});

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=100} );

    //float:
    //f_EPTF_StatMeasure_addData_delta(vl_statIdx_floatVar, { floatVal:= 100.0 }); //it does not refresh the Variable!
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="19.600000"); //100.0-80.4
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_floatVar)!="19.600000");

    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_floatVar,vl_statValue));
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 19.6, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 19.6, vl_eps);

    //noVar:
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_noVar, { intVal:= 0 });//*this is the init*<<== Without this it does not work
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_noVar, { intVal:= 110 });
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_noVar)!="110");

    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_noVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=110});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=110)

    //***** testing f_EPTF_StatMeasure_disableStat_delta *********
    //int
    f_EPTF_StatMeasure_disableStat_delta(vl_statIdx_intVar);
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 560 } )
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=560);
    //expected: no difference, add data blocked:
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="100");
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=100});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=100} );

    //float
    f_EPTF_StatMeasure_disableStat_delta(vl_statIdx_floatVar);
    //expected: no difference, addData blocked
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_floatVar, { floatVal:= 100.0 });
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.0 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="19.600000"); //100.0-80.4
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 19.6, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_disableStat_delta(vl_statIdx_noVar); //While it is applied, the stat. values cannot be refreshed
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_noVar, { intVal:= 200 });
    //expected: the same as previously, because this action is not performed:
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_noVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=110);
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=560);

    //***** testing f_EPTF_StatMeasure_enableStat_delta *********
    //int
    f_EPTF_StatMeasure_enableStat_delta(vl_statIdx_intVar); //now the stat values are refreshed!!!
    //enable refresh:160->560
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=560);
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="400");
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=400});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=400} );

    //f_EPTF_StatMeasure_addData_delta(vl_statIdx_intVar, { intVal:= 170 });
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 170 } )
    //560->170
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="-390");
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=-390});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=-390} );

    //float
    f_EPTF_StatMeasure_enableStat_delta(vl_statIdx_floatVar);
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="0.000000"); 
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 0.0, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_enableStat_delta(vl_statIdx_noVar);
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_noVar, { intVal:= 200 });//110->200
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="90");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_noVar)!="90");

    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_noVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=90});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=90});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=90)

    f_EPTF_Base_cleanup_CT();

  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_delta_temporary
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_delta,
  //       - f_EPTF_StatMeasure_delta2str
  //       - f_EPTF_StatMeasure_value2str for content
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value with more methods
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_delta_temporary() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=0.001; //epsilon: limit of difference

    //Test of f_EPTF_StatMeasure_newStat_delta
    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_delta(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_delta(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_delta(-1);

    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_EPTF_Var_refreshContent(v_floatVarIdx)
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 1 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 1.0 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="-9");
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="-9.000000");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="-9");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_floatVar)!="-9.000000");

    var EPTF_Var_DirectContent vl_statValue;
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail( vl_statValue!={intVal:=-9});

    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_floatVar,vl_statValue));
    f_setverdictFail(vl_statValue!={floatVal:=-9.000000});


    //Test of f_EPTF_StatMeasure_createVarFromStat
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=-9});

    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_setverdictFail(vl_statValue!={floatVal:=-9.0});

    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=0});

    //test if the changes are copied 
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 2 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 2.0 } )

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=2);
    f_EPTF_StatMeasure_Test_checkFloatEquality(f_EPTF_Var_getFloatValue(v_floatVarIdx),2.0, vl_eps);

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="1");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="1");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="1.000000");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_floatVar)!="1.000000");

    f_setverdictFail(not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=1});
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_floatVar,vl_statValue));
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,1.0, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=1} );
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,1.0, vl_eps)

    //test addData/adjustContent when enabled:
    f_EPTF_Var_adjustContent( v_intVarIdx, { intVal:= 4 } );

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=4);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="2");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="2");

    f_setverdictFail(not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=2});

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=2} );

    //float:
    //f_EPTF_StatMeasure_addData_delta(vl_statIdx_floatVar, { floatVal:= 100.0 }); //it does not refresh the Variable!
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 4.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="2.000000");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_floatVar)!="2.000000");

    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_floatVar,vl_statValue));
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,2.0, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 2.0, vl_eps);

    //noVar:
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_noVar, { intVal:= 0 });//*this is the init*<<== Without this it does not work
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_noVar, { intVal:= 110 });
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_noVar)!="110");

    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_noVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=110});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=110)

    //***** testing f_EPTF_StatMeasure_disableStat_delta *********
    //int
    f_EPTF_StatMeasure_disableStat_delta(vl_statIdx_intVar);
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 4 } )
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=4);
    //expected: no difference, add data blocked:
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="2");
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=2});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=2} );

    //float
    f_EPTF_StatMeasure_disableStat_delta(vl_statIdx_floatVar);
    //expected: no difference, addData blocked
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_floatVar, { floatVal:= 4.0 });
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 4.0 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="2.000000");
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 2.0, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_disableStat_delta(vl_statIdx_noVar); //While it is applied, the stat. values cannot be refreshed
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_noVar, { intVal:= 200 });
    //expected: the same as previously, because this action is not performed:
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_noVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=110);

    //***** testing f_EPTF_StatMeasure_enableStat_delta *********
    //int
    f_EPTF_StatMeasure_enableStat_delta(vl_statIdx_intVar); //now the stat values are refreshed!!!
    f_EPTF_Var_refreshContent(v_intVarIdx);
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=4);
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="0");
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=0});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=0} );

    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 8 } )
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_intVar) !="4");
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=4});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=4} );

    //float
    f_EPTF_StatMeasure_enableStat_delta(vl_statIdx_floatVar);
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 8.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="4.000000"); 
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 4.0, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_enableStat_delta(vl_statIdx_noVar);
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_noVar, { intVal:= 200 });//110->200
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="90");
    f_setverdictFail( f_EPTF_StatMeasure_delta2str(vl_statIdx_noVar)!="90");

    f_setverdictFail( not f_EPTF_StatMeasure_getStat_delta(vl_statIdx_noVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=90});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=90});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=90)

    f_EPTF_Base_cleanup_CT();

  }//tc_
///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_delta_noVar_bug
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_delta,
  //       - f_EPTF_StatMeasure_createVarFromStat
  //       - f_EPTF_StatMeasure_value2str for content
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them (they are not used here)
  //    2. Creates a standalone statistics "delta" by calling f_EPTF_StatMeasure_newStat_delta
  //    3. Creates a Variable to the statistics "delta"
  //    4. Change the statistics by calling "f_EPTF_StatMeasure_addData_delta"
  //    5. Compare the new statistics with the added data
  //  Expected Result: The tc is passed if the check in step 5 is true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed but it contains error
  //TR: HJ94384 "TitanSim StatMeasure cannot handle standalone float statistics"

  testcase tc_EPTF_StatMeasure_Test_delta_noVar_bug() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var integer vl_statIdx_noVar:=-1;
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_delta(-1);
    f_EPTF_StatMeasure_LogStat(">>>>>vl_statIdx_noVar: "&int2str(vl_statIdx_noVar),vl_statIdx_noVar);
    f_EPTF_StatMeasure_changeToFloat_delta(vl_statIdx_noVar);
    f_EPTF_StatMeasure_addData_delta(vl_statIdx_noVar, { floatVal:= 110.0 });
    f_setverdictFail(f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)=="110.000000");
    f_EPTF_Base_cleanup_CT();
  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_deltaSum
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_deltaSum,
  //       - f_EPTF_StatMeasure_deltaSum2str
  //       - f_EPTF_StatMeasure_value2str for deltaSum
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value with more methods
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_deltaSum() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=0.001; //epsilon: limit of difference

    //Test of f_EPTF_StatMeasure_newStat_deltaSum
    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_deltaSum(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_deltaSum(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_deltaSum(-1);

    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_EPTF_Var_refreshContent(v_floatVarIdx)
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 20 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 30.0 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="10"); //20-10
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="20.000000");
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_intVar) !="10");
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_floatVar)!="20.000000");

    var EPTF_Var_DirectContent vl_statValue;
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!={intVal:=10});
    f_setverdictFail( not f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_floatVar,vl_statValue));
    f_setverdictFail(vl_statValue!={floatVal:=20.000000});

    //Test of f_EPTF_StatMeasure_createVarFromStat
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=10});

    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_setverdictFail(vl_statValue!={floatVal:=20.0});

    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=0});
    //test if the changes are copied 
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 60 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 80.4 });

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=60);
    f_EPTF_StatMeasure_Test_checkFloatEquality(f_EPTF_Var_getFloatValue(v_floatVarIdx),80.4, vl_eps);

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="50"); //60-20
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_intVar) !="50");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="70.400000"); //80.4 - 30.0
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_floatVar)!="70.400000");

    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=50});
    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_floatVar,vl_statValue);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,70.4, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=50} );
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,70.4, vl_eps)

    //test addData/adjustContent when enabled:
    //int
    //f_EPTF_StatMeasure_addData_deltaSum(vl_statIdx_intVar, { intVal:= 160 });//<<== It cannot be used!!!
    f_EPTF_Var_adjustContent( v_intVarIdx, { intVal:= 160 } );

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=160);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="150"); //160-100
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_intVar) !="150");

    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=150});

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=150} );

    //float:
    //f_EPTF_StatMeasure_addData_deltaSum(vl_statIdx_floatVar, { floatVal:= 100.0 }); //it does not refresh the Variable!
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="90.000000"); //100.0-80.4
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_floatVar)!="90.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_floatVar,vl_statValue);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 90.0, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 90.0, vl_eps);

    //noVar:
    f_EPTF_StatMeasure_addData_deltaSum(vl_statIdx_noVar, { intVal:= 0 });//*this is the init*<<== Without this it does not work
    f_EPTF_StatMeasure_addData_deltaSum(vl_statIdx_noVar, { intVal:= 110 });
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_noVar)!="110");

    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=110)

    //***** testing f_EPTF_StatMeasure_disableStat_deltaSum *********
    //int
    f_EPTF_StatMeasure_disableStat_deltaSum(vl_statIdx_intVar);
    //f_EPTF_StatMeasure_addData_deltaSum(vl_statIdx_intVar, { intVal:= 560 });
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 560 } )
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=560);
    //expected: no difference, add data blocked: 10->160 is the valid:
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_intVar) !="150");
    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=150});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=150} );

    //float
    f_EPTF_StatMeasure_disableStat_deltaSum(vl_statIdx_floatVar);
    //expected: no difference, addData blocked
    //f_EPTF_StatMeasure_addData_deltaSum(vl_statIdx_floatVar, { floatVal:= 100.0 });
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.0 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="90.000000"); //100.0-80.4
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 90.0, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_disableStat_deltaSum(vl_statIdx_noVar); //While it is applied, the stat. values cannot be refreshed
    f_EPTF_StatMeasure_addData_deltaSum(vl_statIdx_noVar, { intVal:= 110 });
    //expected: the same as previously, because this action is not performed:
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_noVar)!="110");
    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=110);

    //***** testing f_EPTF_StatMeasure_enableStat_deltaSum *********
    //int
    f_EPTF_StatMeasure_enableStat_deltaSum(vl_statIdx_intVar); //now the stat values are refreshed!!!
    //enable refresh:160->560
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=560);
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_intVar) !="550");
    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=550});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=550} );

    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 170 } )
    //560->170
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_intVar) !="160");
    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=160});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=160} );

    //float
    f_EPTF_StatMeasure_enableStat_deltaSum(vl_statIdx_floatVar);
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="90.000000");  
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 90.0, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_enableStat_deltaSum(vl_statIdx_noVar);
    f_EPTF_StatMeasure_addData_deltaSum(vl_statIdx_noVar, { intVal:= 200 });//110->200
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="200");
    f_setverdictFail( f_EPTF_StatMeasure_deltaSum2str(vl_statIdx_noVar)!="200");

    v_boolNW := f_EPTF_StatMeasure_getStat_deltaSum(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=200});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=200});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=200)

    f_EPTF_Base_cleanup_CT();

  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_min
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_min,
  //       - f_EPTF_StatMeasure_min2str
  //       - f_EPTF_StatMeasure_value2str for minimum
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value with more methods
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_min() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=0.001; //epsilon: limit of difference

    //Test of f_EPTF_StatMeasure_newStat_min
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_min(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_min(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_min(-1);

    //=1=
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_EPTF_Var_refreshContent(v_floatVarIdx)
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 20 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 30.0 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="10"); //init value
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="10.000000");
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_intVar) !="10");
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_floatVar)!="10.000000");

    var EPTF_Var_DirectContent vl_statValue;
    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=10});
    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_floatVar,vl_statValue);
    f_setverdictFail(vl_statValue!={floatVal:=10.000000});

    //Test of f_EPTF_StatMeasure_createVarFromStat
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=10});

    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_setverdictFail(vl_statValue!={floatVal:=10.0});

    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=0});

    //=2=
    //test if the changes are copied 
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 60 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= -20.4 } )

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=60);
    f_EPTF_StatMeasure_Test_checkFloatEquality(f_EPTF_Var_getFloatValue(v_floatVarIdx),-20.4, vl_eps);

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="10");
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_intVar) !="10");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="-20.400000");
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_floatVar)!="-20.400000");

    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=10});
    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_floatVar,vl_statValue);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,-20.4, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=10} );
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,-20.4, vl_eps)

    //=3=
    //test addData/adjustContent when enabled:
    //int
    //f_EPTF_StatMeasure_addData_min(vl_statIdx_intVar, { intVal:= 160 });//<<== It cannot be used!!!
    f_EPTF_Var_adjustContent( v_intVarIdx, { intVal:= -5 } );

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=-5);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="-5"); //160-100
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_intVar) !="-5");

    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-5});

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=-5} );

    //float:
    //f_EPTF_StatMeasure_addData_min(vl_statIdx_floatVar, { floatVal:= 100.0 }); //it does not refresh the Variable!
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="-20.400000");
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_floatVar)!="-20.400000");

    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_floatVar,vl_statValue);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, -20.4, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, -20.4, vl_eps);

    //noVar:
    f_EPTF_StatMeasure_addData_min(vl_statIdx_noVar, { intVal:= -6 });//*this is the init*<<== Without this it does not work
    f_EPTF_StatMeasure_addData_min(vl_statIdx_noVar, { intVal:= 110 });
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="-6");
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_noVar)!="-6");

    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-6});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-6});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=-6)

    //***** testing f_EPTF_StatMeasure_disableStat_min *********
    //=4Disabled=
    //int
    f_EPTF_StatMeasure_disableStat_min(vl_statIdx_intVar);
    //f_EPTF_StatMeasure_addData_min(vl_statIdx_intVar, { intVal:= 560 });
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= -100 } )
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=-100);
    //expected: no difference, add data blocked: 
    log( ">>:",f_EPTF_StatMeasure_min2str(vl_statIdx_intVar));
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_intVar) !="-5");
    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-5});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=-5} );
    //f_EPTF_StatMeasure_LogAll("===After addData/dis/int===");

    //float
    f_EPTF_StatMeasure_disableStat_min(vl_statIdx_floatVar);
    //expected: no difference, addData blocked
    //f_EPTF_StatMeasure_addData_min(vl_statIdx_floatVar, { floatVal:= -30.11 });
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= -30.11 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="-20.400000"); 
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, -20.4, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_disableStat_min(vl_statIdx_noVar); //While it is applied, the stat. values cannot be refreshed
    f_EPTF_StatMeasure_addData_min(vl_statIdx_noVar, { intVal:= -10 });
    //expected: the same as previously, because this action is not performed:
    log( ">>:",f_EPTF_StatMeasure_min2str(vl_statIdx_noVar));
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="-6");
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_noVar)!="-6");
    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-6});
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-6});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=-6);

    //***** testing f_EPTF_StatMeasure_enableStat_min *********
    //=4Enabled=
    //int
    f_EPTF_StatMeasure_enableStat_min(vl_statIdx_intVar); //now the stat values are refreshed!!!
    //enable refresh:-5->-100
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=-100);
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_intVar) !="-100");
    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-100});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=-100} );
    //f_EPTF_StatMeasure_LogAll("===BeforeS addData_min/int===");
    //f_EPTF_StatMeasure_addData_min(vl_statIdx_intVar, { intVal:= 170 });
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 170 } )
    //Min:-100
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_intVar) !="-100");
    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-100});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=-100} );

    //float
    //Min:-30.11
    f_EPTF_StatMeasure_enableStat_min(vl_statIdx_floatVar);
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= -30.11 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="-30.110000");  
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,-30.11, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_enableStat_min(vl_statIdx_noVar);
    f_EPTF_StatMeasure_addData_min(vl_statIdx_noVar, { intVal:= 200 });
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="-6");
    f_setverdictFail( f_EPTF_StatMeasure_min2str(vl_statIdx_noVar)!="-6");

    v_boolNW := f_EPTF_StatMeasure_getStat_min(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-6});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=-6});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=-6)

    f_EPTF_Base_cleanup_CT();

  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_max
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_max,
  //       - f_EPTF_StatMeasure_maxSum2str
  //       - f_EPTF_StatMeasure_value2str for maximum
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value with more methods
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_max() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=0.001; //epsilon: limit of difference

    //Test of f_EPTF_StatMeasure_newStat_max
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_max(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_max(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_max(-1);

    //=1=
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_EPTF_Var_refreshContent(v_floatVarIdx)
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 20 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 9.0 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="20"); //init value
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="10.000000");
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_intVar) !="20");
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_floatVar)!="10.000000");

    var EPTF_Var_DirectContent vl_statValue;
    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=20});
    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_floatVar,vl_statValue);
    f_setverdictFail(vl_statValue!={floatVal:=10.000000});

    //Test of f_EPTF_StatMeasure_createVarFromStat
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=20});

    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_setverdictFail(vl_statValue!={floatVal:=10.0});

    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue)
    f_setverdictFail(vl_statValue!={intVal:=0});

    //=2=
    //test if the changes are copied 
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 60 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 20.4 } )

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=60);
    f_EPTF_StatMeasure_Test_checkFloatEquality(f_EPTF_Var_getFloatValue(v_floatVarIdx),20.4, vl_eps);

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="60");
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_intVar) !="60");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="20.400000");
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_floatVar)!="20.400000");

    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=60});
    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_floatVar,vl_statValue);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,20.4, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=60} );
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,20.4, vl_eps)

    //=3=
    //test addData/adjustContent when enabled:
    //int
    //f_EPTF_StatMeasure_addData_max(vl_statIdx_intVar, { intVal:= 160 });//<<== It cannot be used!!!
    f_EPTF_Var_adjustContent( v_intVarIdx, { intVal:= -5 } );

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=-5);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="60"); 
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_intVar) !="60");

    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=60});

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=60} );

    //float:
    //f_EPTF_StatMeasure_addData_max(vl_statIdx_floatVar, { floatVal:= 100.0 }); //it does not refresh the Variable!
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.1 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="100.100000");
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_floatVar)!="100.100000");

    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_floatVar,vl_statValue);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 100.1, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 100.1, vl_eps);

    //noVar:
    f_EPTF_StatMeasure_addData_max(vl_statIdx_noVar, { intVal:= -6 });//*this is the init*<<== Without this it does not work
    f_EPTF_StatMeasure_addData_max(vl_statIdx_noVar, { intVal:= 110 });
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_noVar)!="110");

    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=110)

    //***** testing f_EPTF_StatMeasure_disableStat_max *********
    //=4Disabled=
    //int
    f_EPTF_StatMeasure_disableStat_max(vl_statIdx_intVar);
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 61 } )
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=61);
    //expected: no difference, add data blocked: 
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_intVar) !="60");
    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=60});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=60} );

    //float
    f_EPTF_StatMeasure_disableStat_max(vl_statIdx_floatVar);
    //expected: no difference, addData blocked
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 90.0} )
    f_setverdictFail(f_EPTF_Var_getFloatValue(v_floatVarIdx)!=90.0);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="100.100000"); 
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal, 100.1, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_disableStat_max(vl_statIdx_noVar); //While it is applied, the stat. values cannot be refreshed
    f_EPTF_StatMeasure_addData_max(vl_statIdx_noVar, { intVal:= 100 });
    //expected: the same as previously, because this action is not performed:
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_noVar)!="110");
    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=110);

    //***** testing f_EPTF_StatMeasure_enableStat_max *********
    //=4Enabled=
    //int
    f_EPTF_StatMeasure_enableStat_max(vl_statIdx_intVar); //now the stat values are refreshed!!!
    //enable refresh:-5->-100
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=61);
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_intVar) !="61");
    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=61});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=61} );
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 170 } )
    //max:170
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_intVar) !="170");
    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=170});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValue);
    f_setverdictFail( vl_statValue!={ intVal:=170} );

    //float
    //max:100.1
    f_EPTF_StatMeasure_enableStat_max(vl_statIdx_floatVar);
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.1 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="100.100000");  
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue.floatVal,100.1, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_enableStat_max(vl_statIdx_noVar);
    f_EPTF_StatMeasure_addData_max(vl_statIdx_noVar, { intVal:= 90 });
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="110");
    f_setverdictFail( f_EPTF_StatMeasure_max2str(vl_statIdx_noVar)!="110");

    v_boolNW := f_EPTF_StatMeasure_getStat_max(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={intVal:=110});
    f_setverdictFail(f_EPTF_Var_getIntValue(vl_ctrlIdx_noVar)!=110)

    f_EPTF_Base_cleanup_CT();

  }//tc_


///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_mean
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_mean,
  //       - f_EPTF_StatMeasure_mean2str
  //       - f_EPTF_StatMeasure_value2str for deltaSum
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value with more methods
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_mean() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=0.001; //epsilon: limit of difference


    //Test of f_EPTF_StatMeasure_newStat_mean
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_mean(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_mean(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_mean(-1);

    //=1=
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_EPTF_Var_refreshContent(v_floatVarIdx)
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 20 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 9.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="15.000000"); //init value
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="9.500000");
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_intVar) !="15.000000");
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_floatVar)!="9.500000");

    var float vl_statValue:=-1.0; 
    var EPTF_Var_DirectContent vl_statValueContent;
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_mean(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!=15.0);
    v_boolNW := f_EPTF_StatMeasure_getStat_mean(vl_statIdx_floatVar,vl_statValue);
    f_setverdictFail(vl_statValue!=9.5);

    //Test of f_EPTF_StatMeasure_createVarFromStat
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail(vl_statValueContent!={floatVal:= 15.0});

    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    f_EPTF_StatMeasure_Test_checkFloatEquality(f_EPTF_Var_getFloatValue(vl_ctrlIdx_floatVar),9.5, vl_eps);

    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent)
    f_setverdictFail(vl_statValueContent!={floatVal:= 0.0});

    //=2=
    //test if the changes are copied 
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 60 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 41.0 } )
    //f_EPTF_StatMeasure_LogAll("===After New Adjust===");
    //int:
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=60);
    f_EPTF_StatMeasure_Test_checkFloatEquality(f_EPTF_Var_getFloatValue(v_floatVarIdx),41.0, vl_eps);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="30.000000");
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_intVar) !="30.000000");
    //float:
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="20.000000");
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_floatVar)!="20.000000");

    //test of f_EPTF_StatMeasure_getStat_mean
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_mean(vl_statIdx_intVar,vl_statValue));
    f_setverdictFail(vl_statValue!=30.0);
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_mean(vl_statIdx_floatVar,vl_statValue));
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue,20.0, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail(vl_statValueContent.floatVal!=30.0);
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValueContent.floatVal,20.0, vl_eps)

    //=3=
    //test addData/adjustContent when enabled:
    //int
    f_EPTF_Var_adjustContent( v_intVarIdx, { intVal:= 10 } );

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=10);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="25.000000"); 
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_intVar) !="25.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_mean(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!=25.0);

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ floatVal:=25.0} );

    //float:
    //f_EPTF_StatMeasure_addData_mean(vl_statIdx_floatVar, { floatVal:= 100.0 }); //it does not refresh the Variable!
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 40.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="25.000000");
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_floatVar)!="25.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_mean(vl_statIdx_floatVar,vl_statValue);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue, 25.0, vl_eps);

    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValueContent.floatVal, 25.0, vl_eps);

    //noVar:
    f_EPTF_StatMeasure_addData_mean(vl_statIdx_noVar, -10.0 );//*this is the init*<<== Without this it does not work
    f_EPTF_StatMeasure_addData_mean(vl_statIdx_noVar, 110.0);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="50.000000");
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_noVar)!="50.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_mean(vl_statIdx_noVar,vl_statValue);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue, 50.0, vl_eps);
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValueContent.floatVal, 50.0, vl_eps);

    //***** testing f_EPTF_StatMeasure_disableStat_mean *********
    //=4Disabled=
    //int
    f_EPTF_StatMeasure_disableStat_mean(vl_statIdx_intVar);
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 50 } )
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=50);
    //expected: no difference, add data blocked: 
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_intVar) !="25.000000");
    v_boolNW := f_EPTF_StatMeasure_getStat_mean(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!=25.0);
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ floatVal:=25.0} );
    //f_EPTF_StatMeasure_LogAll("===After addData/dis/int===");

    //float
    f_EPTF_StatMeasure_disableStat_mean(vl_statIdx_floatVar);
    //expected: no difference, addData blocked
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 60.0} )
    f_setverdictFail(f_EPTF_Var_getFloatValue(v_floatVarIdx)!=60.0);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="25.000000"); 
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValueContent.floatVal, 25.0, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_disableStat_mean(vl_statIdx_noVar); //While it is applied, the stat. values cannot be refreshed
    f_EPTF_StatMeasure_addData_mean(vl_statIdx_noVar, 50000.0); //it will be forgotten
    //expected: the same as previously, because this action is not performed:
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="50.000000");
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_noVar)!="50.000000");
    v_boolNW := f_EPTF_StatMeasure_getStat_mean(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!= 50.0);
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent);
    f_setverdictFail(vl_statValueContent!={floatVal:=50.0});
    f_setverdictFail(f_EPTF_Var_getFloatValue(vl_ctrlIdx_noVar)!=50.0);

    //***** testing f_EPTF_StatMeasure_enableStat_mean *********
    //=4Enabled=
    //int
    f_EPTF_StatMeasure_enableStat_mean(vl_statIdx_intVar); //now the stat values are refreshed!!!
    //enable refresh:
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=50);
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_intVar) !="30.000000");
    v_boolNW := f_EPTF_StatMeasure_getStat_mean(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!=30.0);
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ floatVal:=30.0} );

    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 30 } )
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_intVar) !="30.000000");
    v_boolNW := f_EPTF_StatMeasure_getStat_mean(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!=30.0);
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ floatVal:=30.0} );

    //float
    f_EPTF_StatMeasure_enableStat_mean(vl_statIdx_floatVar);
    f_EPTF_Var_refreshContent(v_floatVarIdx)
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 20.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="30.000000");  
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValueContent.floatVal,30.0, vl_eps);

    //noVars:
    f_EPTF_StatMeasure_enableStat_mean(vl_statIdx_noVar);
    f_EPTF_StatMeasure_addData_mean(vl_statIdx_noVar, 50.0 );
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="50.000000");
    f_setverdictFail( f_EPTF_StatMeasure_mean2str(vl_statIdx_noVar)!="50.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_mean(vl_statIdx_noVar,vl_statValue); 
    f_setverdictFail(vl_statValue!=50.0);

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent);
    f_setverdictFail(vl_statValue!=50.0);
    f_setverdictFail(f_EPTF_Var_getFloatValue(vl_ctrlIdx_noVar)!=50.0)

    f_EPTF_Base_cleanup_CT();

  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_standardDev
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_standardDev,
  //       - f_EPTF_StatMeasure_standardDev2str
  //       - f_EPTF_StatMeasure_value2str for standardDev
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value with more methods
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready
  testcase tc_EPTF_StatMeasure_Test_standardDev() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_Var_DirectContent vl_statValueContent;
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=0.001; //epsilon: limit of difference

    var float vl_D := 0.0; //expected value
    var float vl_stdDev:=0.0; //the tested value
    var EPTF_FloatList vl_measuredValues := {10.0, 20.0, 60.0, 10.0, 50.0, 30.0}

    //f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    //Test of f_EPTF_StatMeasure_newStat_standardDev
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_standardDev(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_standardDev(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_standardDev(-1);

    vl_D:= f_EPTF_StatMeasure_Test_getStandardDevSq(vl_measuredValues);

    //======== integer test ========== 
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    //for i:=0 it is initialized
    var integer vl_size:= sizeof(vl_measuredValues);
    //===Adjust===
    for(var integer i:=0; i<vl_size;i:=i+1) {
      f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= float2int( vl_measuredValues[i]) } );
    }
    //f_EPTF_StatMeasure_LogAll("===After adjustContent calls===");
    vl_stdDev:= str2float(f_EPTF_StatMeasure_value2str(vl_statIdx_intVar));
    log(">>>vl_stdDev (tested value): ",vl_stdDev);
    log(">>> Square of the expected value:", vl_D);
    //test1:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_D, vl_stdDev, vl_eps)
    //test2:
    f_setverdictFail(f_EPTF_StatMeasure_value2str(vl_statIdx_intVar)!=f_EPTF_StatMeasure_standardDev2str(vl_statIdx_intVar))
    //test3
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_D, vl_statValueContent.floatVal, vl_eps);


    //=========== float test ===============
    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    //===Adjust===
    for(var integer i:=0; i<vl_size;i:=i+1) {
      f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= vl_measuredValues[i] } );
    }
    //f_EPTF_StatMeasure_LogAll("===After float adjustContent calls===");
    vl_stdDev:= str2float(f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar));
    //log(">>>vl_stdDev (tested value): ",vl_stdDev);
    //log(">>> Square of the expected value:", vl_D);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_D, vl_stdDev, vl_eps)
    //test2:
    f_setverdictFail(f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!=f_EPTF_StatMeasure_standardDev2str(vl_statIdx_floatVar))
    //test3
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_D, vl_statValueContent.floatVal, vl_eps);

    //=========== noVars test ==============
    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");
    //===Adjust===
    for(var integer i:=0; i<vl_size;i:=i+1) {
      f_EPTF_StatMeasure_addData_standardDev(vl_statIdx_noVar,vl_measuredValues[i]);
    }
    //f_EPTF_StatMeasure_LogAll("===After float adjustContent calls===");
    vl_stdDev:= str2float(f_EPTF_StatMeasure_value2str(vl_statIdx_noVar));
    //log(">>>vl_stdDev (tested value): ",vl_stdDev);
    //log(">>>Square of the expected value:", vl_D);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_D, vl_stdDev, vl_eps)
    //test2:
    f_setverdictFail(f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!=f_EPTF_StatMeasure_standardDev2str(vl_statIdx_noVar))
    //test3
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_D, vl_statValueContent.floatVal, vl_eps);

    f_EPTF_Base_cleanup_CT();

  }//tc_


///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_EPS
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_EPS,
  //       - f_EPTF_StatMeasure_getMeasurementLength_EPS
  //       - f_EPTF_StatMeasure_getTime_EPS
  //       - f_EPTF_StatMeasure_value2str for EPS
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates 3 EPS type of stats. One for the int variable, one for the float variable and one without variable
  //    4. Clears first statistics (int statistics)
  //    5. Adjust int variable vl_N=100 times. Update the statistics. Then checks the stat value with more methods
  //    6. Clears first statistics
  //    7. Add new data to the statistics vl_N=100 times. Update the statistics. Then checks the stat value with more methods
  //    8. Do 4-7steps with the second statistics (float statistics)
  //    9. Do 6-7steps with the third statistics (noVars statistics)
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready
  testcase tc_EPTF_StatMeasure_Test_EPS() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_Var_DirectContent vl_statValueContent;
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=tsp_eps; //epsilon: limit of difference
    var float vl_measuredTime:=1.0;
    //var float vl_statTime:-0.0
    var float vl_statValue:=0.0; //measured stat value to be tested
    var integer vl_N:= 100; //number of event to be generated
    timer T_1:= 0.0;
    var float vl_expectedValue:=0.0

    //Test of f_EPTF_StatMeasure_newStat_EPS
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_EPS(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_EPS(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_EPS(-1);


    //======== integer test ========== 
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");

    //=== Test for Adjust ===
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_intVar);
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_intVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 1 } );
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_EPS(vl_statIdx_intVar);
    //time:
    //vl_statTime:= f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_intVar);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_intVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_EPS(vl_statIdx_intVar), vl_eps);

    //eps:
    vl_expectedValue:=int2float(vl_N)/vl_measuredTime;
    log("expectedValue: ",vl_expectedValue,", createdVarIdx: ",vl_ctrlIdx_intVar,", value: ",f_EPTF_Var_getFloatValue(vl_ctrlIdx_intVar));
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_intVar), vl_eps);

    //reset
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_intVar);

    //test for addData 
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_intVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_StatMeasure_addData_EPS(vl_statIdx_intVar);
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_EPS(vl_statIdx_intVar);
    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_intVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_EPS(vl_statIdx_intVar), vl_eps);

    //eps:
    vl_expectedValue:=int2float(vl_N)/vl_measuredTime;
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_intVar), vl_eps);
    //log("Measured eps: ",f_EPTF_Var_getFloatValue(vl_ctrlIdx_intVar));
    //log("Expected eps: ",vl_expectedValue);
    //=========== float test ===============
    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");

    //=== Test for Adjust ===
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_floatVar);
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_floatVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 1.0 } );
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_EPS(vl_statIdx_floatVar);
    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_floatVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_EPS(vl_statIdx_floatVar), vl_eps);
    //eps:
    vl_expectedValue:=int2float(vl_N)/vl_measuredTime;
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_floatVar), vl_eps);

    //test for f_EPTF_StatMeasure_getStat_EPS
    v_boolNW := f_EPTF_StatMeasure_getStat_EPS(vl_statIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue,f_EPTF_Var_getFloatValue(vl_ctrlIdx_floatVar), vl_eps)

    //reset
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_floatVar);

    //Test for addData 
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_floatVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_StatMeasure_addData_EPS(vl_statIdx_floatVar);
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_EPS(vl_statIdx_floatVar);
    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_floatVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_EPS(vl_statIdx_floatVar), vl_eps);
    //eps:
    vl_expectedValue:=int2float(vl_N)/vl_measuredTime;
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_floatVar), vl_eps);

    //=========== noVars test ==============
    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");

    //Test for addData 
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_noVar);
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_noVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_StatMeasure_addData_EPS(vl_statIdx_noVar);
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_EPS(vl_statIdx_noVar);
    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_noVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_EPS(vl_statIdx_noVar), vl_eps);
    //eps:
    vl_expectedValue:=int2float(vl_N)/vl_measuredTime;
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_noVar), vl_eps);

    f_EPTF_Base_cleanup_CT();

  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_autoUpdate_EPS
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_update_EPS,
  //       - f_EPTF_StatMeasure_registerDefaultUpdate_EPS
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates 3 EPS type of stats. One for the int variable, one for the float variable and one without variable
  //    3. Set auto update of the statistics. They are updated in every tsp_EPTF_Var_SyncInterval.
  //    4. Clears first statistics (int statistics)
  //    5. Adjust int variable vl_N=100 times. Then checks the stat value with more methods
  //    6. Clears first statistics
  //    7. Add new data to the statistics vl_N=100 times. Then checks the stat value with more methods
  //    8. Do 4-7steps with the second statistics (float statistics)
  //    9. Do 6-7steps with the third statistics (noVars statistics)
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready
  testcase tc_EPTF_StatMeasure_Test_autoUpdate_EPS() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_Var_DirectContent vl_statValueContent;
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=tsp_eps; //epsilon: limit of difference
    var float vl_measuredTime:=2.0;
    //var float vl_statTime:-0.0
    var float vl_statValue:=0.0; //measured stat value to be tested
    var integer vl_N:= 100; //number of event to be generated
    timer T_1:= 1.0;
    var float vl_expectedValue:=0.0
    T_1.start;
    T_1.timeout;

    f_EPTF_Var_adjustContent(v_timerVarIdx,{floatVal:= f_EPTF_Base_getRelTimeInSecs()});

    //Test of f_EPTF_StatMeasure_newStat_EPS
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_EPS(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_EPS(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_EPS(-1);

    // creating EPTF_Var from stat
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");

    //setting auto update
    f_EPTF_StatMeasure_registerDefaultUpdate_EPS(vl_statIdx_intVar);
    f_EPTF_StatMeasure_registerDefaultUpdate_EPS(vl_statIdx_floatVar);
    f_EPTF_StatMeasure_registerDefaultUpdate_EPS(vl_statIdx_noVar);

    //======== integer test ========== 

    //adding function for checking f_EPTF_StatMeasure_getMeasurementLength_EPS() value and expectedValue
    f_EPTF_Var_addSyncCallBackFn(
      refers(f_test_checkDefaultUpdate_EPS),
      {vl_statIdx_intVar, vl_N});

    //=== Test for Adjust ===
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_intVar);
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_intVar);
    f_EPTF_Var_adjustContent(v_timerVarIdx,{floatVal:= f_EPTF_Base_getRelTimeInSecs()});

    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 1 } );
    }
    T_1.timeout;

    //time:
    //vl_statTime:= f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_intVar);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_intVar), vl_eps);

    //=== test for addData ===
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_intVar);
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_intVar);
    f_EPTF_Var_adjustContent(v_timerVarIdx,{floatVal:= f_EPTF_Base_getRelTimeInSecs()});

    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_StatMeasure_addData_EPS(vl_statIdx_intVar);
    }
    T_1.timeout;

    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_intVar), vl_eps);

    // removing checking function
    f_EPTF_Var_removeSyncCallBackFn({
        refers(f_test_checkDefaultUpdate_EPS),
        {vl_statIdx_intVar, vl_N},
        c_EPTF_Var_syncBegin
        });

    //=========== float test ===============

    //adding function for checking f_EPTF_StatMeasure_getMeasurementLength_EPS() value and expectedValue
    f_EPTF_Var_addSyncCallBackFn(
      refers(f_test_checkDefaultUpdate_EPS),
      {vl_statIdx_floatVar, vl_N});

    //=== Test for Adjust ===
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_floatVar);
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_floatVar);
    f_EPTF_Var_adjustContent(v_timerVarIdx,{floatVal:= f_EPTF_Base_getRelTimeInSecs()});

    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 1.0 } );
    }
    T_1.timeout;

    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_floatVar), vl_eps);

    //test for f_EPTF_StatMeasure_getStat_EPS
    v_boolNW := f_EPTF_StatMeasure_getStat_EPS(vl_statIdx_floatVar,vl_statValue)
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue,f_EPTF_Var_getFloatValue(vl_ctrlIdx_floatVar), vl_eps)

    //=== test for addData ===
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_floatVar);
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_floatVar);
    f_EPTF_Var_adjustContent(v_timerVarIdx,{floatVal:= f_EPTF_Base_getRelTimeInSecs()});

    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_StatMeasure_addData_EPS(vl_statIdx_floatVar);
    }
    T_1.timeout;

    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_floatVar), vl_eps);

    // removing checking function
    f_EPTF_Var_removeSyncCallBackFn({
        refers(f_test_checkDefaultUpdate_EPS),
        {vl_statIdx_floatVar, vl_N},
        c_EPTF_Var_syncBegin
        });

    //=========== noVars test ==============

    //adding function for checking f_EPTF_StatMeasure_getMeasurementLength_EPS() value and expectedValue
    f_EPTF_Var_addSyncCallBackFn(
      refers(f_test_checkDefaultUpdate_EPS),
      {vl_statIdx_noVar, vl_N});

    //=== test for addData ===
    f_EPTF_StatMeasure_resetStat_EPS(vl_statIdx_noVar);
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_statIdx_noVar);
    f_EPTF_Var_adjustContent(v_timerVarIdx,{floatVal:= f_EPTF_Base_getRelTimeInSecs()});
    
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_StatMeasure_addData_EPS(vl_statIdx_noVar);
    }
    T_1.timeout;

    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_EPS(vl_statIdx_noVar), vl_eps);

    // removing checking function
    f_EPTF_Var_removeSyncCallBackFn({
        refers(f_test_checkDefaultUpdate_EPS),
        {vl_statIdx_noVar, vl_N},
        c_EPTF_Var_syncBegin
        });
    
    //cleanup
    f_EPTF_Base_cleanup_CT();

  }//tc_
  
///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_chrono
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_chrono,
  //       - f_EPTF_StatMeasure_getTime_chrono
  //       - f_EPTF_StatMeasure_getMeasurementLength_chrono
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value with more methods
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready
  testcase tc_EPTF_StatMeasure_Test_chrono() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_Var_DirectContent vl_statValueContent;
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var float vl_eps:=tsp_eps; //epsilon: limit of difference
    var float vl_measuredTime:=1.0;
    //var float vl_statTime:-0.0
    var float vl_statValue:=0.0; //measured stat value to be tested
    var integer vl_N:= 100; //number of event to be generated
    timer T_1:= 0.0;
    var float vl_expectedValue:=0.0

    //Test of f_EPTF_StatMeasure_newStat_chrono
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_chrono(v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_chrono(v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_chrono(-1);


    //======== integer test ========== 
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");

    //=== Test for Adjust ===
    f_EPTF_StatMeasure_resetStat_chrono(vl_statIdx_intVar);
    f_EPTF_StatMeasure_start_chrono(vl_statIdx_intVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 1 } );
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_chrono(vl_statIdx_intVar);
    //time:
    //vl_statTime:= f_EPTF_StatMeasure_getTime_chrono(vl_statIdx_intVar);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_chrono(vl_statIdx_intVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_chrono(vl_statIdx_intVar), vl_eps);
    vl_expectedValue:=vl_measuredTime;
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_intVar), vl_eps);

    //reset
    f_EPTF_StatMeasure_resetStat_chrono(vl_statIdx_intVar);

    //test for addData 
    f_EPTF_StatMeasure_start_chrono(vl_statIdx_intVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_StatMeasure_addData_chrono(vl_statIdx_intVar);
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_chrono(vl_statIdx_intVar);
    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_chrono(vl_statIdx_intVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_chrono(vl_statIdx_intVar), vl_eps);
    vl_expectedValue:=vl_measuredTime;
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_intVar), vl_eps);
    log("Measured time: ",f_EPTF_Var_getFloatValue(vl_ctrlIdx_intVar));
    log("Expected expected: ",vl_expectedValue);
    //=========== float test ===============
    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");

    //=== Test for Adjust ===
    f_EPTF_StatMeasure_resetStat_chrono(vl_statIdx_floatVar);
    f_EPTF_StatMeasure_start_chrono(vl_statIdx_floatVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 1.0 } );
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_chrono(vl_statIdx_floatVar);
    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_chrono(vl_statIdx_floatVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_chrono(vl_statIdx_floatVar), vl_eps);
    vl_expectedValue:=vl_measuredTime;
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_floatVar), vl_eps);

    //test for f_EPTF_StatMeasure_getStat_chrono
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_chrono(vl_statIdx_floatVar,vl_statValue));
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_statValue,f_EPTF_Var_getFloatValue(vl_ctrlIdx_floatVar), vl_eps)

    //reset
    f_EPTF_StatMeasure_resetStat_chrono(vl_statIdx_floatVar);

    //Test for addData 
    f_EPTF_StatMeasure_start_chrono(vl_statIdx_floatVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_StatMeasure_addData_chrono(vl_statIdx_floatVar);
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_chrono(vl_statIdx_floatVar);
    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_chrono(vl_statIdx_floatVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_chrono(vl_statIdx_floatVar), vl_eps);
    vl_expectedValue:= vl_measuredTime;
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_floatVar), vl_eps);

    //=========== noVars test ==============
    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");

    //Test for addData 
    f_EPTF_StatMeasure_resetStat_chrono(vl_statIdx_noVar);
    f_EPTF_StatMeasure_start_chrono(vl_statIdx_noVar);
    T_1.start(vl_measuredTime);
    for(var integer i:=0; i<vl_N;i:=i+1) {
      f_EPTF_StatMeasure_addData_chrono(vl_statIdx_noVar);
    }
    T_1.timeout;
    f_EPTF_StatMeasure_update_chrono(vl_statIdx_noVar);
    //time:
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getTime_chrono(vl_statIdx_noVar), vl_eps);
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_chrono(vl_statIdx_noVar), vl_eps);
    vl_expectedValue:=vl_measuredTime;
    f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_noVar), vl_eps);
    
    f_EPTF_Base_cleanup_CT();

  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_density
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_density,
  //       - f_EPTF_StatMeasure_mean2str
  //       - f_EPTF_StatMeasure_value2str for density
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the integer and float variable and for standalone statistics
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value with more methods
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready
  testcase tc_EPTF_StatMeasure_Test_density() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test");
    var EPTF_Var_DirectContent vl_statValueContent;
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var EPTF_FloatList vl_measuredValues := {10.0, 20.0, 60.0, 80.0, 100.0, 130.0}
    var EPTF_IntegerList vl_densityResult :={};
    var EPTF_FloatList vl_densityResultFloat:={};
    f_EPTF_StatMeasure_LogAll("===Before NewStat===");
    //Test of f_EPTF_StatMeasure_newStat_density
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_density({10.1,100.0}, v_intVarIdx);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_density({10.1,100.0},v_floatVarIdx);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_density({10.1,100.0},-1);

    //======== integer test ========== 
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    //for i:=0 it is initialized
    var integer vl_size:= sizeof(vl_measuredValues);
    //===Adjust===
    for(var integer i:=0; i<vl_size;i:=i+1) {
      f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= float2int( vl_measuredValues[i]) } );
    }
    f_EPTF_StatMeasure_LogAll("===After adjustContent calls===");

    //test1:
    // 10.0 || 20.0, 60.0, 80.0, || 100.0.  130.0
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_density(vl_statIdx_intVar, vl_densityResult))
    f_setverdictFail( vl_densityResult!={1,3,2} )
    //test2:
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar)!="{1,3,2}")
    f_setverdictFail( f_EPTF_StatMeasure_density2str(vl_statIdx_intVar)!="{1,3,2}")
    //test3
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail(vl_statValueContent.integerlistVal!={1,3,2})

    //test for f_EPTF_StatMeasure_setBoundaries_density:
    f_EPTF_StatMeasure_setBoundaries_density(vl_statIdx_intVar,{ 21.0, 11.0, 51.0, 121.0, 101.0})
    for(var integer i:=0; i<vl_size;i:=i+1) {
      f_EPTF_StatMeasure_addData_density(vl_statIdx_intVar,vl_measuredValues[i]);
    }
    //test1:
    // 10.0 || 20.0 ||  || 60.0, 80.0,  100.0.||  ||  130.0
    f_setverdictFail( f_EPTF_StatMeasure_density2str(vl_statIdx_intVar)!="{1,1,0,3,0,1}");
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_normalized_density(vl_statIdx_intVar, vl_densityResultFloat));
    var EPTF_FloatList vl_expectedDensityFloat:={ 0.166667, 0.166667, 0.0, 0.500000, 0.0, 0.166667}
    for( var integer i:=0; i<sizeof(vl_densityResultFloat); i:=i+1) {
      f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedDensityFloat[i],vl_densityResultFloat[i], 0.0001)
    }
    //=========== float test ===============
    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    //===Adjust===
    for(var integer i:=0; i<vl_size;i:=i+1) {
      f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= vl_measuredValues[i] } );
    }
    f_EPTF_StatMeasure_LogAll("===After float adjustContent calls===");

    //test1:
    // 10.0 || 20.0, 60.0, 80.0, || 100.0.  130.0
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_density(vl_statIdx_floatVar, vl_densityResult))
    f_setverdictFail( vl_densityResult!={1,3,2} )

    //test2:
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="{1,3,2}")
    f_setverdictFail( f_EPTF_StatMeasure_density2str(vl_statIdx_floatVar)!="{1,3,2}")
    //test3
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent);
    f_setverdictFail(vl_statValueContent.integerlistVal!={1,3,2})
    //=========== noVars test ==============
    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");
    //===AddData===
    for(var integer i:=0; i<vl_size;i:=i+1) {
      f_EPTF_StatMeasure_addData_density(vl_statIdx_noVar,vl_measuredValues[i]);
    }
    f_EPTF_StatMeasure_LogAll("===After float adjustContent calls===");

    //test1:
    // 10.0 || 20.0, 60.0, 80.0, || 100.0.  130.0
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_density(vl_statIdx_noVar, vl_densityResult))
    f_setverdictFail( vl_densityResult!={1,3,2} )
    //test2:
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="{1,3,2}")
    f_setverdictFail( f_EPTF_StatMeasure_density2str(vl_statIdx_noVar)!="{1,3,2}")
    //test3
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent);
    f_setverdictFail(vl_statValueContent.integerlistVal!={1,3,2})

    //test for f_EPTF_StatMeasure_setScale_density:
    f_EPTF_StatMeasure_setScale_density(vl_statIdx_noVar, 0.0, 100.0, 11);
    //boundaries:0,10,20,30,40,50,60,70,80,90,100
    for(var integer i:=0; i<vl_size;i:=i+1) {
      f_EPTF_StatMeasure_addData_density(vl_statIdx_noVar,vl_measuredValues[i]);
    }
    f_setverdictFail(not f_EPTF_StatMeasure_getStat_density(vl_statIdx_noVar, vl_densityResult))
    f_setverdictFail( vl_densityResult!={ 0,0,1,1,0,0,0,1,0,1,0,2});

    f_EPTF_Base_cleanup_CT();

  }//tc_

///////////////////////////////////////////////////////////
  //  Testcase:  tc_EPTF_StatMeasure_Test_limits
  //
  //  Purpose:
  //    To test the functions 
  //       - f_EPTF_StatMeasure_newStat_limits,
  //       - f_EPTF_StatMeasure_limits2str
  //       - f_EPTF_StatMeasure_value2str for limits
  //
  //  Requirement:
  //    -
  //
  //  Action:
  //    The testcase runs on EPTF_StatMeasure_Test_CT. Steps:
  //    1. Calls the init function f_EPTF_StatMeasure_Test_init_CT, 
  //       It creates two EPTF_Variables, an int one and a float one and checks them
  //    2. Creates all types of stats for the float variable
  //    3. Checks if the stats are existed and if their type and VarIdx is the ordered.
  //    4. Change the measured values for each statistics with in 3 steps and checks the stat value with more methods
  //    5. Change the measured values when the statistic is disabled. Check if the stat results are unchanged
  //    6. Set the statistics for enabled, Check if the statistics have been refreshed/changed based on the measured values.
  //       For noVars statistics there is no measured Variable therefore it is not refreshed after enebled - the values added have been forgotten
  //  Expected Result: The tc is passed if all checks are true
  //
///////////////////////////////////////////////////////////
  //Status: Ready, Passed
  testcase tc_EPTF_StatMeasure_Test_limits() runs on EPTF_StatMeasure_Test_CT {
    setverdict(pass); //init
    f_EPTF_StatMeasure_Test_init_CT("StatMeasure_test_limits");
    var integer vl_statIdx_intVar:=-1;
    var integer vl_statIdx_floatVar:=-1;
    var integer vl_statIdx_noVar:=-1;
    var integer vl_statIdx_referenceVar:=-1;
    var float vl_eps:=0.001; //epsilon: limit of difference

    //Test of f_EPTF_StatMeasure_newStat_limits
    vl_statIdx_intVar:= f_EPTF_StatMeasure_newStat_limits(v_intVarIdx,{{yellowLimit := 10.1},{redLimit := 100.0}},-,led_green,true);
    vl_statIdx_floatVar:= f_EPTF_StatMeasure_newStat_limits(v_floatVarIdx,{{redLimit := 100.0},{yellowLimit := 10.1}},-,led_green,true);
    vl_statIdx_noVar:= f_EPTF_StatMeasure_newStat_limits(-1,{{yellowLimit := 10.1},{redLimit := 100.0}},-,led_green,true);
    vl_statIdx_referenceVar:= f_EPTF_StatMeasure_newStat_limits(v_floatVarIdx,{{yellowLimit := 10.1},{redLimit := 100.0}},v_intVarIdx,led_green,true);

    //=1=
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_EPTF_Var_refreshContent(v_floatVarIdx)
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 20 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 22.0 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="[led:yellow]20.000000"); //init value
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="[led:yellow]22.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_intVar) !="[led:yellow]20.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_floatVar)!="[led:yellow]22.000000");
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_referenceVar)!="[led:green]22.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_referenceVar)!="[led:green]22.000000");

    var EPTF_StatusLED vl_statValue;
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_yellow, text:="20.000000"});
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_floatVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_yellow, text:="22.000000"});
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:=""});
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_referenceVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="22.000000"});

    //Test of f_EPTF_StatMeasure_createVarFromStat
    var EPTF_Var_DirectContent vl_statValueContent;
    var integer vl_ctrlIdx_intVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_intVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent)
    f_setverdictFail(vl_statValueContent!={statusLEDVal:={color:=led_yellow, text:="20.000000"}});

    var integer vl_ctrlIdx_floatVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_floatVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_setverdictFail(vl_statValueContent!={statusLEDVal:={color:=led_yellow, text:="22.000000"}});

    var integer vl_ctrlIdx_noVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_noVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent)
    f_setverdictFail(vl_statValueContent!={statusLEDVal:={color:=led_green, text:=""}});
 
    var integer vl_ctrlIdx_referenceVar:=f_EPTF_StatMeasure_createVarFromStat(vl_statIdx_referenceVar,"");
    f_EPTF_Var_getContent(vl_ctrlIdx_referenceVar,vl_statValueContent)
    f_setverdictFail(vl_statValueContent!={statusLEDVal:={color:=led_green, text:="22.000000"}});
 
    //=2=
    //test if the changes are copied 
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 60 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= -20.4 } )

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=60);
    f_EPTF_StatMeasure_Test_checkFloatEquality(f_EPTF_Var_getFloatValue(v_floatVarIdx),-20.4, vl_eps);

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="[led:yellow]60.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_intVar) !="[led:yellow]60.000000");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="[led:green]-20.400000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_floatVar)!="[led:green]-20.400000");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_referenceVar)!="[led:green]-20.400000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_referenceVar)!="[led:green]-20.400000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_yellow, text:="60.000000"});
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_floatVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="-20.400000"});
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_referenceVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="-20.400000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ statusLEDVal:={color:=led_yellow, text:="60.000000"}} );
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_setverdictFail( vl_statValueContent!={ statusLEDVal:={color:=led_green, text:="-20.400000"}} );
    f_EPTF_Var_getContent(vl_ctrlIdx_referenceVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ statusLEDVal:={color:=led_green, text:="-20.400000"}} );

    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 0 } )
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 120.4 } )

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=0);
    f_EPTF_StatMeasure_Test_checkFloatEquality(f_EPTF_Var_getFloatValue(v_floatVarIdx),120.4, vl_eps);

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="[led:green]0.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_intVar) !="[led:green]0.000000");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="[led:red]120.400000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_floatVar)!="[led:red]120.400000");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_referenceVar)!="[led:green]120.400000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_referenceVar)!="[led:green]120.400000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="0.000000"});
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_floatVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_red, text:="120.400000"});
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_referenceVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="120.400000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ statusLEDVal:={color:=led_green, text:="0.000000"}} );
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_setverdictFail( vl_statValueContent!={ statusLEDVal:={color:=led_red, text:="120.400000"}} );
    f_EPTF_Var_getContent(vl_ctrlIdx_referenceVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ statusLEDVal:={color:=led_green, text:="120.400000"}} );

    // modify only the reference var
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 100 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="[led:yellow]100.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_intVar) !="[led:yellow]100.000000");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="[led:red]120.400000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_floatVar)!="[led:red]120.400000");

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_referenceVar)!="[led:yellow]120.400000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_referenceVar)!="[led:yellow]120.400000");

    //=3=
    //test addData/adjustContent when enabled:
    //int
    //f_EPTF_StatMeasure_addData_limits(vl_statIdx_intVar, { intVal:= 160 });//<<== It cannot be used!!!
    f_EPTF_Var_adjustContent( v_intVarIdx, { intVal:= -5 } );

    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=-5);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_intVar) !="[led:green]-5.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_intVar) !="[led:green]-5.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="-5.000000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={statusLEDVal:={color:=led_green, text:="-5.000000"}} );

    // the stat with reference
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_referenceVar) !="[led:green]120.400000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_referenceVar) !="[led:green]120.400000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_referenceVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="120.400000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_referenceVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={statusLEDVal:={color:=led_green, text:="120.400000"}} );

    //float:
    //f_EPTF_StatMeasure_addData_limits(vl_statIdx_floatVar, { floatVal:= 100.0 }); //it does not refresh the Variable!
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 100.0 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="[led:yellow]100.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_floatVar)!="[led:yellow]100.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_floatVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_yellow, text:="100.000000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_setverdictFail( vl_statValueContent!={statusLEDVal:={color:=led_yellow, text:="100.000000"}} );

    // the stat with reference
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_referenceVar) !="[led:green]100.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_referenceVar) !="[led:green]100.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_referenceVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="100.000000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_referenceVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={statusLEDVal:={color:=led_green, text:="100.000000"}} );

    //noVar:
    f_EPTF_StatMeasure_addData_limits(vl_statIdx_noVar,  -6.0 );//*this is the init*<<== Without this it does not work
    f_EPTF_StatMeasure_addData_limits(vl_statIdx_noVar,  110.0 );
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="[led:red]110.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_noVar)!="[led:red]110.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_red, text:="110.000000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent);
    f_setverdictFail(vl_statValueContent!={statusLEDVal:={color:=led_red, text:="110.000000"}});

    //***** testing f_EPTF_StatMeasure_disableStat_limits *********
    //=4Disabled=
    //int
    f_EPTF_StatMeasure_disableStat_limits(vl_statIdx_intVar);
    //f_EPTF_StatMeasure_addData_limits(vl_statIdx_intVar, { intVal:= 560 });
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= -100 } )
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=-100);
    //expected: no difference, add data blocked: 
    log( ">>:",f_EPTF_StatMeasure_limits2str(vl_statIdx_intVar));
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_intVar) !="[led:green]-5.000000");
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="-5.000000"});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ statusLEDVal:={color:=led_green, text:="-5.000000"}} );

    // the stat with reference
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_referenceVar) !="[led:green]100.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_referenceVar) !="[led:green]100.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_referenceVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="100.000000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_referenceVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={statusLEDVal:={color:=led_green, text:="100.000000"}} );

    //f_EPTF_StatMeasure_LogAll("===After addData/dis/int===");

    //float
    f_EPTF_StatMeasure_disableStat_limits(vl_statIdx_floatVar);
    //expected: no difference, addData blocked
    //f_EPTF_StatMeasure_addData_limits(vl_statIdx_floatVar, { floatVal:= -30.11 });
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= -30.11 } )

    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="[led:yellow]100.000000");
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_setverdictFail( vl_statValueContent!={statusLEDVal:={color:=led_yellow, text:="100.000000"}} );

    //noVars:
    f_EPTF_StatMeasure_disableStat_limits(vl_statIdx_noVar); //While it is applied, the stat. values cannot be refreshed
    f_EPTF_StatMeasure_addData_limits(vl_statIdx_noVar,  -10.0 );
    //expected: the same as previously, because this action is not performed:
    log( ">>:",f_EPTF_StatMeasure_limits2str(vl_statIdx_noVar));
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="[led:red]110.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_noVar)!="[led:red]110.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_red, text:="110.000000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent);
    f_setverdictFail(vl_statValueContent!={statusLEDVal:={color:=led_red, text:="110.000000"}});

    //***** testing f_EPTF_StatMeasure_enableStat_limits *********
    //=4Enabled=
    //int
    f_EPTF_StatMeasure_enableStat_limits(vl_statIdx_intVar); //now the stat values are refreshed!!!
    //enable refresh:-5->-100
    f_EPTF_Var_refreshContent(v_intVarIdx)
    f_setverdictFail(f_EPTF_Var_getIntValue(v_intVarIdx)!=-100);
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_intVar) !="[led:green]-100.000000");
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_green, text:="-100.000000"});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ statusLEDVal:={color:=led_green, text:="-100.000000"}} );
    //f_EPTF_StatMeasure_LogAll("===BeforeS addData_limits/int===");
    //f_EPTF_StatMeasure_addData_limits(vl_statIdx_intVar, { intVal:= 170 });
    f_EPTF_Var_adjustContent(v_intVarIdx, { intVal:= 170 } )
    //limits:-100
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_intVar) !="[led:red]170.000000");
    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_intVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_red, text:="170.000000"});
    f_EPTF_Var_getContent(vl_ctrlIdx_intVar,vl_statValueContent);
    f_setverdictFail( vl_statValueContent!={ statusLEDVal:={color:=led_red, text:="170.000000"}} );

    //float
    //limits:30.11
    f_EPTF_StatMeasure_enableStat_limits(vl_statIdx_floatVar);
    f_EPTF_Var_adjustContent(v_floatVarIdx, { floatVal:= 30.11 } )
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_floatVar)!="[led:yellow]30.110000");  
    f_EPTF_Var_getContent(vl_ctrlIdx_floatVar,vl_statValueContent)
    f_setverdictFail( vl_statValueContent!={statusLEDVal:={color:=led_yellow, text:="30.110000"}} );

    //noVars:
    f_EPTF_StatMeasure_enableStat_limits(vl_statIdx_noVar);
    f_EPTF_StatMeasure_addData_limits(vl_statIdx_noVar, 200.0);
    f_setverdictFail( f_EPTF_StatMeasure_value2str(vl_statIdx_noVar)!="[led:red]200.000000");
    f_setverdictFail( f_EPTF_StatMeasure_limits2str(vl_statIdx_noVar)!="[led:red]200.000000");

    v_boolNW := f_EPTF_StatMeasure_getStat_limits(vl_statIdx_noVar,vl_statValue);
    f_setverdictFail(vl_statValue!={color:=led_red, text:="200.000000"});

    f_EPTF_Var_getContent(vl_ctrlIdx_noVar,vl_statValueContent);
    f_setverdictFail(vl_statValueContent!={statusLEDVal:={color:=led_red, text:="200.000000"}});

    f_EPTF_Base_cleanup_CT();
// 
  }//tc_

  //=============================================================================
  //===                        Overview of test objects                        ==
  //=============================================================================
  //r=ready
  //r function f_EPTF_StatMeasure_init_CT(in charstring pl_selfName) runs on EPTF_StatMeasure_CT  //1 see tc_EPTF_StatMeasure_Test_initAndCleanup, Status: ready
  //r function f_EPTF_StatMeasure_LogAll(in charstring pl_msg) runs on EPTF_StatMeasure_CT  -- Not Planned
  //r function f_EPTF_StatMeasure_newStat(in integer pl_varIdx, in EPTF_StatMeasure_statType pl_statType) runs on EPTF_StatMeasure_CT return integer
  // see:tc_EPTF_StatMeasure_Test_newStat_int, tc_EPTF_StatMeasure_Test_newStat_float,tc_EPTF_StatMeasure_Test_newStat_noVars, Status:Passed
  //r function f_EPTF_StatMeasure_createAllStats(in integer pl_varIdx) runs on EPTF_StatMeasure_CT return EPTF_IntegerList
  //see:tc_EPTF_StatMeasure_Test_createAllStats
  // function f_EPTF_StatMeasure_resetStats(in EPTF_IntegerList pl_statIdxList) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_getVarIdx(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return integer {
  //see tc_EPTF_StatMeasure_Test_newStat_* and tc_EPTF_StatMeasure_Test_createAllStats

  //r function f_EPTF_StatMeasure_getStatType(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return EPTF_StatMeasure_statType
  //see tc_EPTF_StatMeasure_Test_newStat_* and tc_EPTF_StatMeasure_Test_createAllStats

  //Later:
  //nr function f_EPTF_StatMeasure_resetStat(in integer pl_statIdx) runs on EPTF_StatMeasure_CT <<NOT READY!!!
  //nr function f_EPTF_StatMeasure_enableStat(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_disableStat(in integer pl_statIdx) runs on EPTF_StatMeasure_CT //10

  //r function f_EPTF_StatMeasure_value2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {
  //r function f_EPTF_StatMeasure_createVarFromStat(in integer pl_statIdx, in charstring pl_varName := "") runs on EPTF_StatMeasure_CT return integer {

  //r function f_EPTF_StatMeasure_newStat_content(in integer pl_varIdx) runs on EPTF_StatMeasure_CT return integer {
  //nr function f_EPTF_StatMeasure_resetStat_content(in integer pl_statIdx) runs on EPTF_StatMeasure_CT   -- NOT WORKING, empty function
  //nr function f_EPTF_StatMeasure_enableStat_content(in integer pl_statIdx) runs on EPTF_StatMeasure_CT  -- NOT WORKING, empty function
  //nr function f_EPTF_StatMeasure_disableStat_content(in integer pl_statIdx) runs on EPTF_StatMeasure_CT  -- NOT WORKING, empty function
  //r function f_EPTF_StatMeasure_getStat_content(in integer pl_statIdx, out EPTF_Var_DirectContent pl_statValue) 
  // see tc_EPTF_StatMeasure_Test_content
  //r function f_EPTF_StatMeasure_content2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring 
  // see tc_EPTF_StatMeasure_Test_content

  //r function f_EPTF_StatMeasure_newStat_delta(in integer pl_varIdx := -1) runs on EPTF_StatMeasure_CT return integer
  //see tc_EPTF_StatMeasure_Test_delta
  //nr function f_EPTF_StatMeasure_resetStat_delta(in integer pl_statIdx) runs on EPTF_StatMeasure_CT //20
  //r function f_EPTF_StatMeasure_addData_delta(in integer pl_statIdx, in EPTF_Var_DirectContent pl_newData) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_enableStat_delta(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_disableStat_delta(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_getStat_delta(in integer pl_statIdx, out EPTF_Var_DirectContent pl_statValue) runs on EPTF_StatMeasure_CT return boolean {
  // function f_EPTF_StatMeasure_delta2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {

  //r function f_EPTF_StatMeasure_newStat_deltaSum(in integer pl_varIdx := -1) runs on EPTF_StatMeasure_CT return integer {
  //nr function f_EPTF_StatMeasure_resetStat_deltaSum(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_addData_deltaSum(in integer pl_statIdx, in EPTF_Var_DirectContent pl_newData) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_enableStat_deltaSum(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_disableStat_deltaSum(in integer pl_statIdx) runs on EPTF_StatMeasure_CT //30
  //r function f_EPTF_StatMeasure_getStat_deltaSum(in integer pl_statIdx, out EPTF_Var_DirectContent pl_statValue) runs on EPTF_StatMeasure_CT return boolean {
  //r function f_EPTF_StatMeasure_deltaSum2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {

  //r function f_EPTF_StatMeasure_newStat_min(in integer pl_varIdx := -1) runs on EPTF_StatMeasure_CT return integer {
  //nr function f_EPTF_StatMeasure_resetStat_min(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_addData_min(in integer pl_statIdx, in EPTF_Var_DirectContent pl_newData) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_enableStat_min(in integer pl_statIdx) runs on EPTF_StatMeasure_CT  //50
  //r function f_EPTF_StatMeasure_disableStat_min(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_getStat_min(in integer pl_statIdx, out EPTF_Var_DirectContent pl_statValue) runs on EPTF_StatMeasure_CT return boolean {
  // function f_EPTF_StatMeasure_min2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {

  //r function f_EPTF_StatMeasure_newStat_max(in integer pl_varIdx := -1) runs on EPTF_StatMeasure_CT return integer//40
  //nr function f_EPTF_StatMeasure_resetStat_max(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_addData_max(in integer pl_statIdx, in EPTF_Var_DirectContent pl_newData) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_enableStat_max(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_disableStat_max(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_getStat_max(in integer pl_statIdx, out EPTF_Var_DirectContent pl_statValue) runs on EPTF_StatMeasure_CT return boolean {
  // function f_EPTF_StatMeasure_max2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {

  //r function f_EPTF_StatMeasure_newStat_mean(in integer pl_varIdx := -1) runs on EPTF_StatMeasure_CT return integer {
  //nr function f_EPTF_StatMeasure_resetStat_mean(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_addData_mean(in integer pl_statIdx, in float pl_newData) runs on EPTF_StatMeasure_CT 
  //r function f_EPTF_StatMeasure_enableStat_mean(in integer pl_statIdx) runs on EPTF_StatMeasure_CT //50
  //r function f_EPTF_StatMeasure_disableStat_mean(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_getStat_mean(in integer pl_statIdx, out float pl_statValue) runs on EPTF_StatMeasure_CT return boolean {
  //r function f_EPTF_StatMeasure_mean2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {

  //r function f_EPTF_StatMeasure_newStat_standardDev(in integer pl_varIdx := -1) runs on EPTF_StatMeasure_CT return integer {
  //nr function f_EPTF_StatMeasure_resetStat_standardDev(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_addData_standardDev(in integer pl_statIdx, in float pl_newData) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_enableStat_standardDev(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_disableStat_standardDev(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_getStat_standardDev(in integer pl_statIdx, out float pl_statValue) runs on EPTF_StatMeasure_CT return boolean {
  //nr function f_EPTF_StatMeasure_getStat_standardDev_mean(in integer pl_statIdx, out float pl_statValue) runs on EPTF_StatMeasure_CT return boolean //60
  //nr function f_EPTF_StatMeasure_getStatIdx_standardDev_mean(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return integer {
  //r function f_EPTF_StatMeasure_standardDev2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {
  //nr function f_EPTF_StatMeasure_standardDev_mean2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {

  //r function f_EPTF_StatMeasure_newStat_EPS(in integer pl_varIdx := -1) runs on EPTF_StatMeasure_CT return integer {
  //r function f_EPTF_StatMeasure_resetStat_EPS(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_startMeasurement_EPS(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_addData_EPS(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_enableStat_EPS(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_disableStat_EPS(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_getStat_EPS(in integer pl_statIdx, out float pl_statValue) runs on EPTF_StatMeasure_CT return boolean //70
  //nr function f_EPTF_StatMeasure_EPS2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {
  //r function f_EPTF_StatMeasure_getMeasurementLength_EPS(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return float {
  //r function f_EPTF_StatMeasure_getTime_EPS(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return float {
  //r function f_EPTF_StatMeasure_update_EPS(in integer pl_statIdx, in float pl_period := -1.0, in boolean pl_enableRefresh := true) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_registerDefaultUpdate_EPS(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  
  //r function f_EPTF_StatMeasure_newStat_chrono(in integer pl_varIdx := -1) runs on EPTF_StatMeasure_CT return integer {
  //r function f_EPTF_StatMeasure_resetStat_chrono(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_start_chrono(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_addData_chrono(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_enableStat_chrono(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_disableStat_chrono(in integer pl_statIdx) runs on EPTF_StatMeasure_CT //80
  //r function f_EPTF_StatMeasure_getStat_chrono(in integer pl_statIdx, out float pl_statValue) runs on EPTF_StatMeasure_CT return boolean {
  //nr function f_EPTF_StatMeasure_chrono2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {
  //nr function f_EPTF_StatMeasure_getMeasurementLength_chrono(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return float {
  //r function f_EPTF_StatMeasure_getTime_chrono(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return float {
  //r function f_EPTF_StatMeasure_update_chrono(in integer pl_statIdx, in boolean pl_enableRefresh := true) runs on EPTF_StatMeasure_CT {

  //r function f_EPTF_StatMeasure_newStat_density(in EPTF_FloatList pl_boundaries, in integer pl_varIdx := -1) runs on EPTF_StatMeasure_CT return integer {
  //r function f_EPTF_StatMeasure_setBoundaries_density(in integer pl_statIdx, in EPTF_FloatList pl_boundaries, in boolean pl_enableUpdate := true) runs on EPTF_StatMeasure_CT {
  //*not ready function f_EPTF_StatMeasure_setScale_density(in integer pl_statIdx, in float pl_min, in float pl_max, in integer pl_n, in EPTF_StatMeasure_density_scale pl_scale := linear) runs on EPTF_StatMeasure_CT {
  //*not ready function f_EPTF_StatMeasure_resetStat_density(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_addData_density(in integer pl_statIdx, in float pl_newData) runs on EPTF_StatMeasure_CT //90
  //nr function f_EPTF_StatMeasure_enableStat_density(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //nr function f_EPTF_StatMeasure_disableStat_density(in integer pl_statIdx) runs on EPTF_StatMeasure_CT {
  //r function f_EPTF_StatMeasure_getStat_density(in integer pl_statIdx, out EPTF_IntegerList pl_statValue) runs on EPTF_StatMeasure_CT return boolean {
  //r function f_EPTF_StatMeasure_getStat_normalized_density(in integer pl_statIdx, out EPTF_FloatList pl_statValue) runs on EPTF_StatMeasure_CT return boolean {
  //r function f_EPTF_StatMeasure_density2str(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {
  //nr function f_EPTF_StatMeasure_createVarFromStat_boundaries_density(in integer pl_statIdx, in charstring pl_varName := "") runs on EPTF_StatMeasure_CT return integer {

  //************* From here the functions are private:**********************************

  // function f_EPTF_StatMeasure_registerCreatedVar(in integer pl_statIdx, in integer pl_varIdx) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_updateCreatedVar(in integer pl_statIdx, in boolean pl_enableRefresh := true) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_registerCreatedVarForBoundaries_density(in integer pl_statIdx, in integer pl_varIdx) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_updateCreatedVarForBoundaries_density(in integer pl_statIdx, in boolean pl_enableRefresh := true) runs on EPTF_StatMeasure_CT //70
  // function f_EPTF_StatMeasure_stat2Var(in integer pl_statIdx, inout EPTF_Var_DirectContent pl_retVal) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_stat2Var_calcFn(in integer pl_idx, in EPTF_IntegerList pl_argList, in EPTF_IntegerList pl_nonVarArgList, inout EPTF_Var_DirectContent pl_retVal) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_valueIsAvailable(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return boolean {
  // function f_EPTF_StatMeasure_update_delta_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_update_deltaSum_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_update_min_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_update_max_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_update_mean_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_update_standardDev_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_update_density_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT //100
  // function f_EPTF_StatMeasure_update_boundaries_density_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_addData_EPS_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_addData_chrono_ProstProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_StatMeasure_CT {
  // function f_EPTF_StatMeasure_getStatName(in integer pl_statIdx) runs on EPTF_StatMeasure_CT return charstring {
  // function f_EPTF_StatMeasure_integerList2str(in EPTF_IntegerList pl_integerList) return charstring {
  // function f_EPTF_StatMeasure_cleanup_CT() runs on EPTF_StatMeasure_CT  //see tc_EPTF_StatMeasure_Test_initAndCleanup, Ready
  // function f_EPTF_StatMeasure_bubblesort(inout EPTF_FloatList pl_list) //117



}// FunctionTest

control {
  execute(tc_EPTF_StatMeasure_Test_complex());
  execute(tc_EPTF_StatMeasure_Test_custom());
  execute(tc_EPTF_StatMeasure_Test_percentile95());
  execute(tc_EPTF_StatMeasure_Test_percentileP());
  execute(tc_EPTF_StatMeasure_Test_percentile95_initStatValue());
  execute(tc_EPTF_StatMeasure_Test_initAndCleanup());
  execute(tc_EPTF_StatMeasure_Test_selftest());
  execute(tc_EPTF_StatMeasure_Test_newStat_int());
  execute(tc_EPTF_StatMeasure_Test_newStat_Type_int());
  execute(tc_EPTF_StatMeasure_Test_newStat_float());
  execute(tc_EPTF_StatMeasure_Test_newStat_Type_float());
  execute(tc_EPTF_StatMeasure_Test_newStat_noVars());
  execute(tc_EPTF_StatMeasure_Test_newStat_Type_noVars());
  execute(tc_EPTF_StatMeasure_Test_createAllStats());
  execute(tc_EPTF_StatMeasure_Test_content());
  execute(tc_EPTF_StatMeasure_Test_delta());
  execute(tc_EPTF_StatMeasure_Test_delta_temporary());
  execute(tc_EPTF_StatMeasure_Test_delta_noVar_bug()); // TR: HJ94384
  execute(tc_EPTF_StatMeasure_Test_deltaSum());
  execute(tc_EPTF_StatMeasure_Test_min());
  execute(tc_EPTF_StatMeasure_Test_max());
  execute(tc_EPTF_StatMeasure_Test_mean());
  execute(tc_EPTF_StatMeasure_Test_standardDev());
  execute(tc_EPTF_StatMeasure_Test_EPS());
  execute(tc_EPTF_StatMeasure_Test_autoUpdate_EPS());
  execute(tc_EPTF_StatMeasure_Test_chrono());
  execute(tc_EPTF_StatMeasure_Test_density());
  execute(tc_EPTF_StatMeasure_Test_limits());
  
}

} // end of module