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