test/StatMeasure/EPTF_StatMeasure_Test_Functions.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_Functions {

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;

group BasicTestFunctions {

///////////////////////////////////////////////////////////
//  Function: f_postProc_logValue
//
///////////////////////////////////////////////////////////
  
function f_postProc_logValue(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_Var_CT {
  var EPTF_Var_DirectContent vl_currentContent;
  f_EPTF_Var_getContent(pl_idx, vl_currentContent);
  log("Value of variable ", pl_idx, ": ", vl_currentContent);
}

///////////////////////////////////////////////////////////
//  Function: f_setverdictFail
//
///////////////////////////////////////////////////////////

function f_setverdictFail(in boolean pl_condition) {
  if (pl_condition) {
    setverdict(fail);
  }
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_StatMeasure_statList
//
///////////////////////////////////////////////////////////
function f_EPTF_StatMeasure_statList() runs on EPTF_StatMeasure_CT return EPTF_StatMeasure_StatisticsList {
  return statList;
}

///////////////////////////////////////////////////////////
//  Function: f_test_percentile95
//
///////////////////////////////////////////////////////////

function f_test_percentile95() runs on EPTF_StatMeasure_Test_CT
{
  var integer i, j, vl_stat, vl_var;
  var boolean vl_available;
  var float vl_floatVal;
  var integer vl_intVal;
  var EPTF_IntegerList vl_intValues;
  var EPTF_FloatList vl_floatValues;

  ////////////////////////////////////////////////////////////////////////////
  // INT VAR
  f_EPTF_Var_newInt("myInt",0, vl_var);  
  vl_stat := f_EPTF_StatMeasure_newStat_percentile95({}, vl_var);

  f_EPTF_StatMeasure_setScale_percentile95(vl_stat,0.0,10.0,6);

  // Test 0: stat value is 4 (3 is element of [2, 4])
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=3});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  // Test 1: reset really resets statistics
  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);
  f_EPTF_Var_adjustContent(vl_var,{intVal:=5});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 6.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 2: stat value is 0 after added elements to below 0 density interval
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=-10});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 0.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 3: move stat value on interval left and back right after
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=3});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  for (i := 0; i < 56; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=1});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=1});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=3});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 4: move stat value on interval left (to the lowest interval) and back right after
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=1});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  for (i := 0; i < 56; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=-1});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=-1});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 0.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=1});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 4: move stat value on interval right and back right after
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=1});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=3});  

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 5: move stat value on interval right (to the highest interval) and back right after
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=1});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=11});  

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != -1.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 6: like be for but move from the second highest interval
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=9});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 10.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=11});  

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != -1.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 7: move to right slowly
  for (i := 0; i < 95; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=1});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  for (i := 0; i < 5; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=7});  
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=7});  

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 8.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 8: without boundaries, stat value should be the maximum of elements
  f_EPTF_StatMeasure_setBoundaries_percentile95(vl_stat, {});  

  var integer vl_max := 0;
  vl_intValues := {};
  for (i := 0; i < 100; i := i + 1) 
  {
    vl_intVal := float2int(20.0 * rnd() - 5.0);   
    if (vl_intVal > vl_max) { vl_max := vl_intVal; }

    f_EPTF_Var_adjustContent(vl_var,{intVal:=vl_intVal});  
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != int2float(vl_max));

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 9: same result when random
  var float vl_floatVal1, vl_floatVal2, vl_statVal;  
  var integer jj, kk, densityIdx;
  var EPTF_FloatList vl_boundaries;

  for (j := 0; j < 25; j := j + 1) 
  {
    vl_max := 0;
    vl_intValues := {};

    f_EPTF_StatMeasure_setScale_percentile95(vl_stat,0.0,10.0,6);

    // generate 100 random values
    for (i := 0; i < 100; i := i + 1) 
    {
      vl_intVal := float2int(10.0 * rnd()); 
      if (vl_intVal > vl_max) { vl_max := vl_intVal; }

      vl_intValues[sizeof(vl_intValues)] := vl_intVal;

      f_EPTF_Var_adjustContent(vl_var,{intVal:=vl_intVal});  
    }

    log("New element list (ORIG): ", vl_intValues);

    vl_available :=
      f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal1);
    log("Statvalue: ", vl_floatVal1);

    f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

    // randomly swaps data
    for (i := 0; i < 1000; i := i + 1) {
      jj := float2int(99.999999 * rnd());
      kk := float2int(99.999999 * rnd());

      vl_intVal := vl_intValues[jj];
      vl_intValues[jj] := vl_intValues[kk];
      vl_intValues[kk] := vl_intVal;
    }

    //log("New element list (SWAPPED): ", vl_intValues);

    // add swapped values again
    for (i := 0; i < 100; i := i + 1) 
    {
      f_EPTF_Var_adjustContent(vl_var,{intVal:=vl_intValues[i]});  
    }

    vl_available :=
      f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal2);
    //log("Statvalue: ", vl_floatVal2);

    // compute statistics
    vl_floatValues := {};
    for (i := 0; i < 100; i := i + 1) {
      vl_floatValues[i] := int2float(vl_intValues[i]);
    }
    f_EPTF_StatMeasure_bubblesort(vl_floatValues);

    //log("Percentile 95 element: ", vl_floatValues[95]); // 0 - 94 -> 95

    // acquire percentile95 stat value manually
    densityIdx := f_EPTF_StatMeasure_getStatIdx_density_percentile95(vl_stat);
    vl_boundaries := f_EPTF_StatMeasure_getBoundaries_density(densityIdx);
    vl_statVal := int2float(vl_max);
    for (i := 0; i < sizeof(vl_boundaries); i := i + 1) {
      if (vl_floatValues[95] < vl_boundaries[i]) { vl_statVal := vl_boundaries[i]; }        
    }
    //log("Stat value must be: ", vl_statVal);  

    f_setverdictFail(vl_floatVal1 != vl_statVal);
    //log("Value 1 ok!");
    f_setverdictFail(vl_floatVal2 != vl_statVal);
    //log("Value 2 ok!");

    f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  }

  // Test 10: same result when random
  for (j := 0; j < 25; j := j + 1) 
  {
    vl_max := 0;
    vl_intValues := {};

    f_EPTF_StatMeasure_setBoundaries_percentile95(vl_stat,{ 5.0 });

    // generate 100 random values
    for (i := 0; i < 100; i := i + 1) 
    {
      vl_intVal := float2int(10.0 * rnd()); 
      if (vl_intVal > vl_max) { vl_max := vl_intVal; }

      vl_intValues[sizeof(vl_intValues)] := vl_intVal;

      f_EPTF_Var_adjustContent(vl_var,{intVal:=vl_intVal});  
    }

    log("New element list (ORIG): ", vl_intValues);

    vl_available :=
      f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal1);
    log("Statvalue: ", vl_floatVal1);

    f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

    // randomly swaps data
    for (i := 0; i < 1000; i := i + 1) {
      jj := float2int(99.999999 * rnd());
      kk := float2int(99.999999 * rnd());

      vl_intVal := vl_intValues[jj];
      vl_intValues[jj] := vl_intValues[kk];
      vl_intValues[kk] := vl_intVal;
    }

    log("New element list (SWAPPED): ", vl_intValues);

    // add swapped values again
    for (i := 0; i < 100; i := i + 1) 
    {
      f_EPTF_Var_adjustContent(vl_var,{intVal:=vl_intValues[i]});  
    }
    
    vl_available :=
      f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal2);
    log("Statvalue: ", vl_floatVal2);

    // compute statistics
    vl_floatValues := {};
    for (i := 0; i < 100; i := i + 1) {
      vl_floatValues[i] := int2float(vl_intValues[i]);
    }
    f_EPTF_StatMeasure_bubblesort(vl_floatValues);

    log("Percentile 95 element: ", vl_floatValues[95]); // 0 - 94 -> 95

    // acquire percentile95 stat value manually
    densityIdx := f_EPTF_StatMeasure_getStatIdx_density_percentile95(vl_stat);
    vl_boundaries := f_EPTF_StatMeasure_getBoundaries_density(densityIdx);
    vl_statVal := int2float(vl_max);
    for (i := 0; i < sizeof(vl_boundaries); i := i + 1) {
      if (vl_floatValues[95] < vl_boundaries[i]) { vl_statVal := vl_boundaries[i]; }        
    }
    log("Stat value must be: ", vl_statVal);  

    f_setverdictFail(vl_floatVal1 != vl_statVal);
    log("Value 1 ok!");
    f_setverdictFail(vl_floatVal2 != vl_statVal);
    log("Value 2 ok!");

    f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);
  }

  // Test 11: test if the 95 percentile of 0,1,2,..99 is 95.0:
  f_EPTF_StatMeasure_setScale_percentile95(vl_stat,0.0,100.0,101);
  
  // add data:
  for(i:=0; i<100; i:=i+1) {
      f_EPTF_Var_adjustContent(vl_var,{intVal:=i});
  }
  
  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 95.0);
  

  ////////////////////////////////////////////////////////////////////////////
  // FLOAT VAR
  f_EPTF_Var_newFloat("myFloat",0.0, vl_var);  
  vl_stat := f_EPTF_StatMeasure_newStat_percentile95({}, vl_var);

  f_EPTF_StatMeasure_setScale_percentile95(vl_stat,0.0,10.0,6);

  // Test 0: stat value is 4 (3 is element of [2, 4])
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=3.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  // Test 1: reset really resets statistics
  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);
  f_EPTF_Var_adjustContent(vl_var,{floatVal:=5.0});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 6.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 2: stat value is 0 after added elements to below 0 density interval
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=-10.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 0.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 3: move stat value on interval left and back right after
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=3.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  for (i := 0; i < 56; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=1.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  f_EPTF_Var_adjustContent(vl_var,{floatVal:=1.0});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{floatVal:=3.0});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 4: move stat value on interval left (to the lowest interval) and back right after
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=1.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  for (i := 0; i < 56; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=-1.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{floatVal:=-1.0});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 0.0);

  f_EPTF_Var_adjustContent(vl_var,{floatVal:=1.0});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 4: move stat value on interval right and back right after
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=1.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{floatVal:=3.0});  

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 5: move stat value on interval right (to the highest interval) and back right after
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=1.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{floatVal:=11.0});  

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != -1.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 6: like be for but move from the second highest interval
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=9.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 10.0);

  f_EPTF_Var_adjustContent(vl_var,{floatVal:=11.0});  

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != -1.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 7: move to right slowly
  for (i := 0; i < 95; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=1.0});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  for (i := 0; i < 5; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{floatVal:=7.0});  
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{floatVal:=7.0});  

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 8.0);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 8: without boundaries, stat value should be the maximum of elements
  f_EPTF_StatMeasure_setBoundaries_percentile95(vl_stat, {});  

  var float vl_maxF := 0.0;
  vl_floatValues := {};
  for (i := 0; i < 100; i := i + 1) 
  {
    vl_floatVal := 20.0 * rnd() - 5.0;   
    if (vl_floatVal > vl_maxF) { vl_maxF := vl_floatVal; }

    f_EPTF_Var_adjustContent(vl_var,{floatVal:=vl_floatVal});  
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  //log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != vl_maxF);

  f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  // Test 9: same result when random  
  for (j := 0; j < 25; j := j + 1) 
  {
    vl_maxF := 0.0;
    vl_floatValues := {};

    f_EPTF_StatMeasure_setScale_percentile95(vl_stat,0.0,10.0,6);

    // generate 100 random values
    for (i := 0; i < 100; i := i + 1) 
    {
      vl_floatVal := 10.0 * rnd(); 
      if (vl_floatVal > vl_maxF) { vl_maxF := vl_floatVal; }

      vl_floatValues[sizeof(vl_floatValues)] := vl_floatVal;

      f_EPTF_Var_adjustContent(vl_var,{floatVal:=vl_floatVal});  
    }

    //log("New element list (ORIG): ", vl_floatValues);

    vl_available :=
      f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal1);
    //log("Statvalue: ", vl_floatVal1);

    f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

    // randomly swaps data
    for (i := 0; i < 1000; i := i + 1) {
      jj := float2int(99.999999 * rnd());
      kk := float2int(99.999999 * rnd());

      vl_floatVal := vl_floatValues[jj];
      vl_floatValues[jj] := vl_floatValues[kk];
      vl_floatValues[kk] := vl_floatVal;
    }

    //log("New element list (SWAPPED): ", vl_floatValues);

    // add swapped values again
    for (i := 0; i < 100; i := i + 1) 
    {
      f_EPTF_Var_adjustContent(vl_var,{floatVal:=vl_floatValues[i]});  
    }

    vl_available :=
      f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal2);
    log("Statvalue: ", vl_floatVal2);

    // compute statistics
    f_EPTF_StatMeasure_bubblesort(vl_floatValues);

    log("Percentile 95 element: ", vl_floatValues[95]); // 0 - 94 -> 95

    // acquire percentile95 stat value manually
    densityIdx := f_EPTF_StatMeasure_getStatIdx_density_percentile95(vl_stat);
    vl_boundaries := f_EPTF_StatMeasure_getBoundaries_density(densityIdx);
    vl_statVal := vl_maxF;
    for (i := 0; i < sizeof(vl_boundaries); i := i + 1) {
      if (vl_floatValues[95] < vl_boundaries[i]) { vl_statVal := vl_boundaries[i]; }        
    }
    log("Stat value must be: ", vl_statVal);  

    f_setverdictFail(vl_floatVal1 != vl_statVal);
    log("Value 1 ok!");
    f_setverdictFail(vl_floatVal2 != vl_statVal);
    log("Value 2 ok!");

    f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

  }

  // Test 10: same result when random
  for (j := 0; j < 25; j := j + 1) 
  {
    vl_maxF := 0.0;
    vl_floatValues := {};

    f_EPTF_StatMeasure_setBoundaries_percentile95(vl_stat,{ 5.0 });

    // generate 100 random values
    for (i := 0; i < 100; i := i + 1) 
    {
      vl_floatVal := 10.0 * rnd(); 
      if (vl_floatVal > vl_maxF) { vl_maxF := vl_floatVal; }

      vl_floatValues[sizeof(vl_floatValues)] := vl_floatVal;

      f_EPTF_Var_adjustContent(vl_var,{floatVal:=vl_floatVal});  
    }

    log("New element list (ORIG): ", vl_floatValues);

    vl_available :=
      f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal1);
    log("Statvalue: ", vl_floatVal1);

    f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);

    // randomly swaps data
    for (i := 0; i < 1000; i := i + 1) {
      jj := float2int(99.999999 * rnd());
      kk := float2int(99.999999 * rnd());

      vl_floatVal := vl_floatValues[jj];
      vl_floatValues[jj] := vl_floatValues[kk];
      vl_floatValues[kk] := vl_floatVal;
    }

    log("New element list (SWAPPED): ", vl_floatValues);

    // add swapped values again
    for (i := 0; i < 100; i := i + 1) 
    {
      f_EPTF_Var_adjustContent(vl_var,{floatVal:=vl_floatValues[i]});  
    }

    vl_available :=
      f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal2);
    log("Statvalue: ", vl_floatVal2);

    // compute statistics
    f_EPTF_StatMeasure_bubblesort(vl_floatValues);

    log("Percentile 95 element: ", vl_floatValues[95]); // 0 - 94 -> 95

    // acquire percentile95 stat value manually
    densityIdx := f_EPTF_StatMeasure_getStatIdx_density_percentile95(vl_stat);
    vl_boundaries := f_EPTF_StatMeasure_getBoundaries_density(densityIdx);
    vl_statVal := vl_maxF;
    for (i := 0; i < sizeof(vl_boundaries); i := i + 1) {
      if (vl_floatValues[95] < vl_boundaries[i]) { vl_statVal := vl_boundaries[i]; }        
    }
    log("Stat value must be: ", vl_statVal);  

    f_setverdictFail(vl_floatVal1 != vl_statVal);
    log("Value 1 ok!");
    f_setverdictFail(vl_floatVal2 != vl_statVal);
    log("Value 2 ok!");

    f_EPTF_StatMeasure_resetStat_percentile95(vl_stat);
  }

  // Test 11: test if the 95 percentile of 0.0,1.0,2.0,..99.0 is 95.0:
  f_EPTF_StatMeasure_setScale_percentile95(vl_stat,0.0,100.0,101);
  
  // add data:
  for(i:=0; i<100; i:=i+1) {
      f_EPTF_Var_adjustContent(vl_var,{floatVal:=int2float(i)});  
  }
  
  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 95.0);  

  // Test 12: same test, but if the 95 percentile of 0.9,1.9,2.9,..99.9 is still 95.0:
  f_EPTF_StatMeasure_setScale_percentile95(vl_stat,0.0,100.0,101);
  
  // add data:
  for(i:=0; i<100; i:=i+1) {
      f_EPTF_Var_adjustContent(vl_var,{floatVal:=int2float(i)+0.9});  
  }
  
  vl_available :=
    f_EPTF_StatMeasure_getStat_percentile95(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 95.0);  
}

///////////////////////////////////////////////////////////
//  Function: f_test_percentileP
//
///////////////////////////////////////////////////////////

function f_test_percentileP() runs on EPTF_StatMeasure_Test_CT
{
  var integer i, j, vl_stat, vl_var;
  var boolean vl_available;
  var float vl_floatVal;
  var integer vl_intVal;
  var EPTF_IntegerList vl_intValues;
  var EPTF_FloatList vl_floatValues;

  ////////////////////////////////////////////////////////////////////////////
  // INT VAR
  f_EPTF_Var_newInt("myInt",0, vl_var);  
  vl_stat := f_EPTF_StatMeasure_newStat_percentileP({}, 0.5, vl_var); //median statistics

  f_EPTF_StatMeasure_setScale_percentileP(vl_stat,0.0,10.0,6);

  // Test 0: stat value is 4 (3 is element of [2, 4])
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=3});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentileP(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  // Test 1: reset really resets statistics
  f_EPTF_StatMeasure_resetStat_percentileP(vl_stat);
  f_EPTF_Var_adjustContent(vl_var,{intVal:=5});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentileP(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 6.0);

  f_EPTF_StatMeasure_resetStat_percentileP(vl_stat);

  // Test 2: stat value is 0 after added elements to below 0 density interval
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=-10});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentileP(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 0.0);

  f_EPTF_StatMeasure_resetStat_percentileP(vl_stat);

  // Test 3: changing resolution
    f_EPTF_StatMeasure_setScale_percentileP(vl_stat,0.0,10.0,11);
  
  for (i := 0; i < 3; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=3});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentileP(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 4.0);

  for (i := 0; i < 4; i := i + 1) {
    f_EPTF_Var_adjustContent(vl_var,{intVal:=1});
  }

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentileP(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=1});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentileP(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_Var_adjustContent(vl_var,{intVal:=3});

  vl_available :=
    f_EPTF_StatMeasure_getStat_percentileP(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 2.0);

  f_EPTF_StatMeasure_resetStat_percentileP(vl_stat);

  ////////////////////////////////////////////////////////////////////////////
  // FLOAT VAR
  f_EPTF_Var_newFloat("myFloat",0.0, vl_var);  
  vl_stat := f_EPTF_StatMeasure_newStat_percentileP({}, 0.5, vl_var);

// Test 11: test if the 50 percentile of 0.0,1.0,2.0,..99.0 is 50.0:
  f_EPTF_StatMeasure_setScale_percentileP(vl_stat,0.0,100.0,101);
  
  // add data:
  for(i:=0; i<100; i:=i+1) {
      f_EPTF_Var_adjustContent(vl_var,{floatVal:=int2float(i)});  
  }
  
  vl_available :=
    f_EPTF_StatMeasure_getStat_percentileP(vl_stat, vl_floatVal);
  log("Statvalue: ", vl_floatVal);

  f_setverdictFail(vl_floatVal != 50.0);

}

///////////////////////////////////////////////////////////
//  Function: f_test_custom
//
///////////////////////////////////////////////////////////
function f_test_custom() runs on EPTF_StatMeasure_Test_CT
{
  var integer vl_var, vl_stat, vl_statvar;
  var EPTF_Var_DirectContent vl_dc;
  var float vl_statfloat;
  var boolean vl_available;

  f_EPTF_Var_newFloat("myCUSTOMFloat",0.0, vl_var); 

  vl_stat := f_EPTF_StatMeasure_newStat(vl_var, custom);

  f_EPTF_StatMeasure_setProperties_custom(vl_stat,
    "MyCustomStat3",
    refers(f_customTest_newStat),     {},
    refers(f_customTest_addData),     {},    
    refers(f_customTest_getStat),     {},
    refers(f_customTest_stat2Str),    {},
    refers(f_customTest_createVarFromStat), {},
    refers(f_customTest_resetStat),   {},
    refers(f_customTest_enableStat),  {},
    refers(f_customTest_disableStat), {});

  vl_statvar := f_EPTF_StatMeasure_createVarFromStat( // must be used, unless created var not registered
    vl_stat, "myCUSTOMStatVar");  

  var charstring vl_statName := f_EPTF_StatMeasure_getStatName(vl_stat);
  log("Stat name: ", vl_statName);

  var charstring vl_generatedName := "EPTF_StatMeasure."&int2str(vl_stat)&".myCUSTOMFloat.stat.MyCustomStat3";
  log("Generated stat name: ", vl_generatedName);

  f_setverdictFail(vl_statName != vl_generatedName);

  log("Adjusting variable!");
  f_EPTF_Var_adjustContent(vl_var, {floatVal:=5.0});

  log("Float value of var: ", f_EPTF_Var_getFloatValue(vl_var));

  vl_available := 
    f_EPTF_StatMeasure_getStat_custom(vl_stat, vl_dc);

  vl_statfloat := f_EPTF_Var_getFloatValue(vl_statvar);

  log("Statvalue: ", vl_dc, " / Statvarvalue: ", vl_statfloat);

  f_setverdictFail(vl_dc.floatVal != 25.0);
  f_setverdictFail(vl_statfloat != 25.0);
}

///////////////////////////////////////////////////////////
//  Function: f_customTest_addData
//
//  Purpose:
// custom statistics test
// statistics calculates the value of its base var multiplied
// with an all time increasing (one by one) variable
// if there is no variable, value should be zero
///////////////////////////////////////////////////////////
function f_customTest_addData(
  in integer pl_statIdx, 
  in EPTF_IntegerList pl_argList,
  in EPTF_Var_DirectContent pl_newData)
runs on EPTF_StatMeasure_Test_CT
{
  log("### addData");

  var EPTF_Var_DirectContent vl_statVal;
  var integer vl_varIdx := f_EPTF_StatMeasure_getVarIdx(pl_statIdx);  

  if (vl_varIdx == -1) {
    v_customResult := 0.0;
    return;
  }

  log("Var index: " & int2str(vl_varIdx));

  if (f_EPTF_StatMeasure_isReset(pl_statIdx)) 
  {
    log("RESET");
    v_customResult := 0.0; 
    //statList[pl_statIdx].reset:=false;
    //f_customTest_addData(pl_statIdx, pl_argList, pl_newData);
  } 
  //else 
  //{
    log("ADDDATA");

    var float vl_newval;
    f_EPTF_Var_getContent(vl_varIdx, vl_statVal);
    if (ischosen(vl_statVal.intVal)) 
    { 
      vl_newval := int2float(vl_statVal.intVal);
      v_customResult := v_customMulti * vl_newval;
    } 
    else if (ischosen(vl_statVal.floatVal)) 
    {
      vl_newval := vl_statVal.floatVal;
      v_customResult := v_customMulti * vl_newval;
    } else {
      log("Invalid statistics type!");
      setverdict(fail);
    } 

    log("New value: " & float2str(vl_newval));
    log("Custom multi: " & float2str(v_customMulti));
    log("Custom result: " & float2str(v_customResult));
  //}
}

///////////////////////////////////////////////////////////
//  Function: f_customTest_newStat
//
///////////////////////////////////////////////////////////

function f_customTest_newStat(
  in integer pl_statIdx, 
  in EPTF_IntegerList pl_argList)
runs on EPTF_StatMeasure_Test_CT
{
  log("### newStat");
  // No user interaction needed
}

///////////////////////////////////////////////////////////
//  Function: f_customTest_getStat
//
///////////////////////////////////////////////////////////

function f_customTest_getStat(
  in integer pl_statIdx, 
  in EPTF_IntegerList pl_argList,
  out EPTF_Var_DirectContent pl_statValue)
runs on EPTF_StatMeasure_Test_CT return boolean
{
  log("### getStat");
  
  pl_statValue := { floatVal := v_customResult };
  return true;
} 

///////////////////////////////////////////////////////////
//  Function: f_customTest_stat2Str
//
///////////////////////////////////////////////////////////

function f_customTest_stat2Str(
  in integer pl_statIdx, 
  in EPTF_IntegerList pl_argList)
runs on EPTF_StatMeasure_Test_CT return charstring
{
  log("### stat2Str");
  
  var EPTF_Var_DirectContent vl_value;
  
  return "Custom: " & float2str(vl_value.floatVal);
} 

///////////////////////////////////////////////////////////
//  Function: f_customTest_createVarFromStat
//
///////////////////////////////////////////////////////////

function f_customTest_createVarFromStat(
  in integer pl_statIdx, 
  in EPTF_IntegerList pl_argList,
  in charstring pl_varName)
runs on EPTF_StatMeasure_Test_CT return integer
{
  log("### createVarFromStat");
  
  var integer vl_varIdx;
  var EPTF_Var_DirectContent vl_value;

  var boolean vl_noWarning := 
    f_customTest_getStat(pl_statIdx, pl_argList, vl_value);
  
  f_EPTF_Var_newFloat(pl_varName, vl_value.floatVal, vl_varIdx);

  return vl_varIdx;
} 

///////////////////////////////////////////////////////////
//  Function: f_customTest_resetStat
//
///////////////////////////////////////////////////////////

function f_customTest_resetStat(
  in integer pl_statIdx, 
  in EPTF_IntegerList pl_argList)
runs on EPTF_StatMeasure_Test_CT
{
  log("### resetStat");
  // No user interaction needed
}

///////////////////////////////////////////////////////////
//  Function: f_customTest_enableStat
//
///////////////////////////////////////////////////////////

function f_customTest_enableStat(
  in integer pl_statIdx, 
  in EPTF_IntegerList pl_argList)
runs on EPTF_StatMeasure_Test_CT
{
  log("### enableStat");
  
  // No user interaction needed
}

///////////////////////////////////////////////////////////
//  Function: f_customTest_disableStat
//
///////////////////////////////////////////////////////////

function f_customTest_disableStat(
  in integer pl_statIdx, 
  in EPTF_IntegerList pl_argList)
runs on EPTF_StatMeasure_Test_CT
{
  log("### disableStat");
  
  // No user interaction needed
}

///////////////////////////////////////////////////////////
//  Function: f_customTest_startStat
//
///////////////////////////////////////////////////////////

function f_customTest_startStat(
  in integer pl_statIdx, 
  in EPTF_IntegerList pl_argList)
runs on EPTF_StatMeasure_Test_CT
{
  log("### startStat");

  // Unused - FIXME
}

///////////////////////////////////////////////////////////
//  Function: f_test_checkDefaultUpdate_EPS
//
//  function can be used to check EPS statistics value is as much as expected
///////////////////////////////////////////////////////////

function f_test_checkDefaultUpdate_EPS(
  in EPTF_IntegerList pl_argList)
runs on EPTF_StatMeasure_Test_CT
{
  log("### f_test_checkDefaultUpdate_EPS() called, pl_argList: ",pl_argList,", tsp_eps: ",tsp_eps);
  //pl_argList[0] - statIdx
  //pl_argList[1] - vl_N

  var EPTF_Var_DirectContent vl_content;
  var float vl_measuredTime;
  f_EPTF_Var_getContent(v_timerVarIdx, vl_content);
  vl_measuredTime := f_EPTF_Base_getRelTimeInSecs() - vl_content.floatVal;

  //eps:
  var float vl_expectedValue := int2float(pl_argList[1])/vl_measuredTime;
  var integer vl_ctrlIdx_var := f_EPTF_StatMeasure_getCreatedVarIdx(pl_argList[0]);
  log("expected value: ",vl_expectedValue,", real value: ",f_EPTF_Var_getFloatValue(vl_ctrlIdx_var),", vl_ctrlIdx_var: ",vl_ctrlIdx_var);
  log("expected measurement length: ",vl_measuredTime,", real measurement length: ",f_EPTF_StatMeasure_getMeasurementLength_EPS(pl_argList[0]));
  
  f_EPTF_StatMeasure_Test_checkFloatEquality(vl_expectedValue, f_EPTF_Var_getFloatValue(vl_ctrlIdx_var), tsp_eps);
  f_EPTF_StatMeasure_Test_checkFloatEquality(vl_measuredTime, f_EPTF_StatMeasure_getMeasurementLength_EPS(pl_argList[0]), tsp_eps);

}

///////////////////////////////////////////////////////////
//  Function: f_createConfig
//
///////////////////////////////////////////////////////////

function f_createConfig() runs on EPTF_StatMeasure_Test_CT {

  var integer vl_intValue;
  log("Creating intVar with initial value: 10");
  f_EPTF_Var_newInt("intVar",10, v_intVarIdx);
  f_EPTF_Var_CT_LogAll("----- newInt -------");
  f_EPTF_Var_Log("--intVar--",v_intVarIdx);
  vl_intValue := f_EPTF_Var_getIntValue(v_intVarIdx);
  log("getIntValue: ", vl_intValue);
  f_setverdictFail((vl_intValue!=10));

  var float vl_floatValue;
  log("Creating floatVar with initial value: 10");
  //  var integer v_intVarIdx;
  f_EPTF_Var_newFloat("floatVar",10.0, v_floatVarIdx);
  f_EPTF_Var_CT_LogAll("----- newFloat -------");
  f_EPTF_Var_Log("--floatVar--",v_floatVarIdx);
  vl_floatValue := f_EPTF_Var_getFloatValue(v_floatVarIdx);
  log("getFloatValue: ", vl_floatValue);
  f_setverdictFail((vl_floatValue!=10.0));

  var float vl_timerValue;
  log("Creating floatVar with initial value: 0");
  //  var integer v_intVarIdx;
  f_EPTF_Var_newFloat("timerVar",0.0, v_timerVarIdx);
  f_EPTF_Var_CT_LogAll("----- newFloat -------");
  f_EPTF_Var_Log("--timerVar--",v_timerVarIdx);
  vl_timerValue := f_EPTF_Var_getFloatValue(v_timerVarIdx);
  log("getFloatValue: ", vl_timerValue);
  f_setverdictFail((vl_timerValue!=0.0));
  

  f_EPTF_Var_addPostProcFn(v_intVarIdx, {refers(f_postProc_logValue),{}});
  f_EPTF_Var_addPostProcFn(v_floatVarIdx, {refers(f_postProc_logValue),{}});
  f_EPTF_Var_CT_LogAll("----- POSTPROC SET -------");
}


//this function is the same as f_EPTF_StatMeasure_Test_createAllStats but handles case "pl_varIdx:=-1"
//This shall be removed in R3 where the original function corrected.
function f_EPTF_StatMeasure_Test_createAllStats(in integer pl_varIdx) runs on EPTF_StatMeasure_CT return EPTF_IntegerList {
  var EPTF_IntegerList vl_idxList := {};
  if(pl_varIdx!=-1) {
    vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_content(pl_varIdx);
  }
  vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_delta(pl_varIdx);
  vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_deltaSum(pl_varIdx);
  vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_min(pl_varIdx);
  vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_max(pl_varIdx);
  vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_mean(pl_varIdx);
  vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_standardDev(pl_varIdx);
  vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_EPS(pl_varIdx);
  vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_chrono(pl_varIdx);
  vl_idxList[sizeof(vl_idxList)] := f_EPTF_StatMeasure_newStat_density({},pl_varIdx);
  //...
  return vl_idxList;
}
}//groupBasicTestFunctions

group FunctionTestFunctions {


///////////////////////////////////////////////////////////
//  Function: f_EPTF_StatMeasure_Test_init_CT
//
//  Purpose:
//     Initializes the component EPTF_StatMeasure_Test_CT
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
  function f_EPTF_StatMeasure_Test_init_CT(in charstring pl_selfName) runs on EPTF_StatMeasure_Test_CT {
    if( v_EPTF_StatMeasure_Test_initialized ) { return }
    f_EPTF_StatMeasure_init_CT(pl_selfName);
    f_EPTF_Base_registerCleanup(refers(f_EPTF_StatMeasure_Test_cleanup_CT));
    v_intVarIdx:= -1;
    v_floatVarIdx:=-1;
    v_timerVarIdx:=-1;
    f_createConfig(); //<=== Two Variables are introduced here: an integer and a float one
    v_EPTF_StatMeasure_Test_initialized:= true;
  }//f_

///////////////////////////////////////////////////////////
//  Function: EPTF_StatMeasure_Test_cleanup_CT
//
//  Purpose:
//     cleans the component EPTF_StatMeasure_Test_CT
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
  function f_EPTF_StatMeasure_Test_cleanup_CT () runs on EPTF_StatMeasure_Test_CT {
    v_EPTF_StatMeasure_Test_initialized:=false;
  }//f_

///////////////////////////////////////////////////////////
//  Function: EPTF_StatMeasure_Test_checkFloatStatByIdx
//
//  Purpose:
//     cleans the component EPTF_StatMeasure_Test_CT
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
  function f_EPTF_StatMeasure_Test_checkFloatStatValue(
    in integer pl_statIdx_floatVar,
    in float pl_expectedValue) 
  runs on EPTF_StatMeasure_Test_CT 
  {
    f_setverdictFail( f_EPTF_StatMeasure_value2str(pl_statIdx_floatVar)!=float2str(pl_expectedValue));
  }

///////////////////////////////////////////////////////////
//  Function: EPTF_StatMeasure_Test_checkFloatStatByIdx
//
//  Purpose:
//     cleans the component EPTF_StatMeasure_Test_CT
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
  function f_EPTF_StatMeasure_Test_checkFloatEquality(
    in float pl_value,
    in float pl_expectedValue,
    in float pl_epsilon) 
  {
    f_setverdictFail( (pl_value - pl_expectedValue > pl_epsilon) or (pl_value - pl_expectedValue < -pl_epsilon));
  }

}//FunctionTestFunctions

function f_EPTF_StatMeasure_Test_getStandardDevSq( in EPTF_FloatList pl_values ) return float {
  var float vl_mean:=0.0;
  var integer vl_size:= sizeof(pl_values);
  var float vl_floatSize:= int2float(vl_size)
  var float vl_D2 :=0.0;

  if(vl_size==0) { return 0.0 };

  for(var integer i:=0; i<vl_size; i:=i+1) {
    vl_mean:= vl_mean+ pl_values[i];
  }
  vl_mean:= vl_mean / vl_floatSize;
  log(">>>Mean: ", vl_mean);
  for(var integer j:=0;j<vl_size; j:=j+1) {
    vl_D2:= vl_D2+(pl_values[j]-vl_mean)*(pl_values[j]-vl_mean);
  }
  vl_D2:= vl_D2/vl_floatSize;
  return vl_D2;
}

}//module