| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // 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_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: |
| // - |
| |