| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // Copyright (c) 2000-2019 Ericsson Telecom AB // |
| // // |
| // All rights reserved. This program and the accompanying materials // |
| // are made available under the terms of the Eclipse Public License v2.0 // |
| // which accompanies this distribution, and is available at // |
| // https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////// |
| // Module: EPTF_HostAdmin_Test_Testcases |
| // |
| // Purpose: |
| // This module contains testcases for testing EPTF Load measurement |
| // |
| // Module Parameters: |
| // tsp_demoInterval - *float* - interval of testing, default: 30.0 |
| // tsp_demoRefreshPeriod - *float* - local-measurement refresh period, default: 2.0 |
| // |
| // Module depends on: |
| // <EPTF_CLL_HostAdmin_BaseFunctions> |
| // <EPTF_CLL_HostAdmin_Definitions> |
| // <EPTF_CLL_HostAdmin_Functions> |
| // <EPTF_CLL_Variable_Functions> |
| // <EPTF_CLL_Base_Functions> |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_HostAdmin_Test_Functions> |
| // <EPTF_HostAdmin_Test_Definitions> |
| // |
| // Current Owner: |
| // Balazs Barcsik (ebalbar) |
| // |
| // Last Review Date: |
| // 2008-02-14 |
| // |
| // Detailed Comments: |
| // - |
| /////////////////////////////////////////////////////////// |
| |
| module EPTF_HostAdmin_Test_Testcases { |
| //========================================================================= |
| // Import Part |
| //========================================================================= |
| import from EPTF_CLL_HostAdmin_BaseFunctions all; |
| |
| import from EPTF_CLL_HostAdmin_Definitions all; |
| import from EPTF_CLL_HostAdmin_Functions all; |
| |
| import from EPTF_CLL_Variable_Definitions all; |
| import from EPTF_CLL_Variable_Functions all; |
| |
| import from EPTF_CLL_Base_Definitions all; |
| import from EPTF_CLL_Base_Functions all; |
| import from EPTF_CLL_Common_Definitions all; |
| |
| import from EPTF_HostAdmin_Test_Functions all; |
| import from EPTF_HostAdmin_Test_Definitions all; |
| |
| import from EPTF_CLL_UIHandler_Definitions all; |
| import from EPTF_CLL_UIHandler_WidgetFunctions all; |
| |
| import from EPTF_CLL_DataSource_Functions all; |
| import from EPTF_CLL_DataSource_Definitions all; |
| import from EPTF_CLL_DataSourceClient_Functions all; |
| |
| import from EPTF_CLL_HostAdminServer_Definitions all; |
| import from EPTF_CLL_HostAdminServer_Functions all; |
| |
| //========================================================================= |
| // Module Parameters |
| //========================================================================= |
| modulepar float tsp_demoInterval := 10.0; |
| modulepar float tsp_demoRefreshPeriod := 2.0; |
| |
| modulepar integer tsp_customGUI_test_Manual_numberOfPTCs := 10; |
| |
| modulepar charstring tsp_demoHost := "127.0.0.1"; |
| modulepar EPTF_CharstringList tsp_uiDemoHostList := {}; |
| modulepar charstring tsp_HostAdmin_guiXmlName := "hostadmin_gui.xml" |
| |
| //========================================================================= |
| // TestCases |
| //========================================================================= |
| testcase tc_HostAdmin_LocalMeasure() runs on EPTF_HostAdmin_Base_Test_CT |
| { |
| timer T_interval := tsp_demoInterval; |
| timer T_refresh := tsp_demoRefreshPeriod; |
| |
| f_EPTF_HostAdmin_Base_init_CT("test"); |
| log("Number of CPUs: ", v_EPTF_HostAdmin_numCPUs); |
| log("Physical memory: ", v_EPTF_HostAdmin_physicalMemory, " kB"); |
| |
| T_interval.start; |
| T_refresh.start; |
| alt { |
| [] T_interval.timeout |
| { |
| setverdict(pass); |
| } |
| [] T_refresh.timeout |
| { |
| f_EPTF_HostAdmin_Base_update(); |
| log("======================================="); |
| if(v_EPTF_HostAdmin_numCPUs < 2) { |
| log("CPU load: ", v_EPTF_HostAdmin_testerHostLoad); |
| } else { |
| log("Average CPU load: ", v_EPTF_HostAdmin_testerHostLoad); |
| for(var integer i:=0; i<v_EPTF_HostAdmin_numCPUs; i:=i+1) { |
| log("Load of CPU", i, ": ", v_EPTF_HostAdmin_CPULoads[i]); |
| } |
| } |
| log("Free memory: ", v_EPTF_HostAdmin_freeMemory, " kB"); |
| T_refresh.start; |
| repeat; |
| } |
| } |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_EPTF_HostAdmin_Test_behavior |
| // |
| // Purpose: |
| // to test f_EPTF_HostAdmin_behavior() function |
| // |
| // Requirement: |
| // - |
| // |
| // Action: |
| // - create and start a hostAdmin component with f_EPTF_HostAdmin_behavior() function call |
| // - checks that whether post proc function called or not (it tests the EPTF variables of the hostadmin component variables) |
| // |
| // Expected Result: |
| // - post proc function calls in every tsp_EPTF_HostAdmin_loadMeasurementRefreshTime time |
| /////////////////////////////////////////////////////////// |
| testcase tc_EPTF_HostAdmin_Test_behavior() runs on EPTF_HostAdmin_Test_CT |
| { |
| |
| |
| f_EPTF_Var_init_CT("Test_behavior"); |
| |
| hostAdm := EPTF_HostAdmin_CT.create; |
| hostAdm.start(f_EPTF_HostAdmin_behavior(c_hostAdmin_name)); |
| |
| f_demo_subscribe(); |
| |
| timer t_wait4Refresh; |
| t_wait4Refresh.start(0.1); |
| alt { |
| []t_wait4Refresh.timeout { if(v_freeMemoryCalled>0 and v_hostLoadCalled>0 and v_CPUloadCalled>0){t_test.start}else{t_wait4Refresh.start(0.1)} repeat } |
| [] t_test.timeout |
| { |
| if (v_freeMemoryCalled - 1 == c_called) { |
| setverdict(pass); |
| } else { |
| log("Error: reading free memory called ", v_freeMemoryCalled, " time(s), expected: ", c_called); |
| setverdict(fail); |
| } |
| if (v_hostLoadCalled - 1 == c_called) { |
| setverdict(pass); |
| } else { |
| log("Error: reading free memory called ", v_hostLoadCalled, " time(s), expected: ", c_called); |
| setverdict(fail); |
| } |
| if (v_CPUloadCalled == (c_called + 1) * f_EPTF_Var_getIntValue(v_numCPUs_k)) { |
| setverdict(pass); |
| } else { |
| log("Error: reading free memory called ", v_CPUloadCalled, " time(s), expected: ", c_called * f_EPTF_Var_getIntValue(v_numCPUs_k)); |
| setverdict(fail); |
| } |
| |
| } |
| [] any component.done |
| { |
| log("HostAdmin stopped unexpectedly."); |
| setverdict(fail); |
| } |
| } |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_EPTF_HostAdmin_Base_Test_InitMeasInterface |
| // |
| // Purpose: |
| // to test f_EPTF_HostAdmin_Base_init_CT() function |
| // |
| // Requirement: |
| // - |
| // |
| // Action: |
| // - calls f_EPTF_HostAdmin_Base_init_CT() function |
| // - checks the value of the hostadmin component variables |
| // |
| // Expected Result: |
| // - the value of the component variables is the same as the initiated |
| /////////////////////////////////////////////////////////// |
| testcase tc_EPTF_HostAdmin_Base_Test_InitMeasInterface() runs on EPTF_HostAdmin_Base_Test_CT { |
| timer t; |
| f_EPTF_HostAdmin_Base_init_CT("test"); |
| |
| log("Number of CPUs: ", f_EPTF_HostAdmin_Base_getNumCPUs()); |
| if(f_EPTF_HostAdmin_Base_getNumCPUs() > 0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getNumCPUs(), ", expected: >0"); |
| setverdict(fail); |
| } |
| |
| log("Physical memory: ", f_EPTF_HostAdmin_Base_getPhysicalMemory()); |
| if(f_EPTF_HostAdmin_Base_getPhysicalMemory() != 0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getPhysicalMemory(), ", expected: not 0"); |
| setverdict(fail); |
| } |
| |
| log("Average host load: ", f_EPTF_HostAdmin_Base_getTesterHostLoad()); |
| if(f_EPTF_HostAdmin_Base_getTesterHostLoad() >= 0.0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getTesterHostLoad(), ", expected: >=0.0"); |
| setverdict(fail); |
| } |
| |
| for (var integer i := 0; i < f_EPTF_HostAdmin_Base_getNumCPUs(); i := i + 1) { |
| log("Load of host #", i, ": ", f_EPTF_HostAdmin_Base_getCPULoads(i)); |
| if(f_EPTF_HostAdmin_Base_getCPULoads(i) >= 0.0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getCPULoads(i), ", expected: >=0.0"); |
| setverdict(fail); |
| } |
| } |
| |
| log("Free memory: ", f_EPTF_HostAdmin_Base_getFreeMemory()); |
| if(f_EPTF_HostAdmin_Base_getFreeMemory() >= 0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getFreeMemory(), ", expected: >=0"); |
| setverdict(fail); |
| } |
| |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_EPTF_HostAdmin_Base_Test_CleanupMeasInterface |
| // |
| // Purpose: |
| // to test f_EPTF_Base_cleanup_CT() function |
| // |
| // Requirement: |
| // - |
| // |
| // Action: |
| // - calls f_EPTF_Base_init_CT() function |
| // - calls f_EPTF_HostAdmin_Base_init_CT() function |
| // - update the component variables after several seconds |
| // - calls f_EPTF_Base_cleanup_CT() function |
| // - calls f_EPTF_Base_init_CT() function |
| // - calls f_EPTF_HostAdmin_Base_init_CT() function |
| // - checks the value of the hostadmin component variables |
| // - calls f_EPTF_Base_cleanup_CT() function |
| // |
| // Expected Result: |
| // - the value of the component variables is the same as the initiated |
| /////////////////////////////////////////////////////////// |
| testcase tc_EPTF_HostAdmin_Base_Test_CleanupMeasInterface() runs on EPTF_HostAdmin_Base_Test_CT { |
| |
| timer t; |
| var EPTF_IntegerList vl_temp; |
| |
| f_EPTF_HostAdmin_Base_init_CT("test"); |
| t.start(5.0); |
| t.timeout; |
| for(var integer i := 0; i < 1000; i := i + 1) { |
| vl_temp[i] := i; |
| } |
| f_EPTF_HostAdmin_Base_update(); |
| f_EPTF_Base_cleanup_CT(); |
| // f_EPTF_Base_init_CT("test-InitMeasInterface"); |
| // f_EPTF_HostAdmin_Base_init_CT("test"); |
| if(f_EPTF_HostAdmin_Base_getNumCPUs() == 0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getNumCPUs(), ", expected: 0"); |
| setverdict(fail); |
| } |
| |
| log("PH mem: ", f_EPTF_HostAdmin_Base_getPhysicalMemory()); |
| if(f_EPTF_HostAdmin_Base_getPhysicalMemory() == 0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getPhysicalMemory(), ", expected: 0"); |
| setverdict(fail); |
| } |
| |
| if(f_EPTF_HostAdmin_Base_getTesterHostLoad() == 0.0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getTesterHostLoad(), ", expected: 0.0"); |
| setverdict(fail); |
| } |
| |
| |
| for (var integer i := 0; i < f_EPTF_HostAdmin_Base_getNumCPUs(); i := i + 1) { |
| if(f_EPTF_HostAdmin_Base_getCPULoads(i) == 0.0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getCPULoads(i), ", expected: 0.0"); |
| setverdict(fail); |
| } |
| } |
| |
| if(f_EPTF_HostAdmin_Base_getFreeMemory() == 0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getFreeMemory(), ", expected: 0"); |
| setverdict(fail); |
| } |
| f_EPTF_Base_cleanup_CT() |
| // f_EPTF_Base_cleanup_CT(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_EPTF_HostAdmin_Base_Test_update |
| // |
| // Purpose: |
| // to test f_EPTF_HostAdmin_Base_update() function |
| // |
| // Requirement: |
| // - |
| // |
| // Action: |
| // - calls f_EPTF_Base_init_CT() function |
| // - calls f_EPTF_HostAdmin_Base_init_CT() function |
| // - update the component variables after several seconds |
| // - checks the value of the hostadmin component variables |
| // - calls f_EPTF_Base_cleanup_CT() function |
| // |
| // Expected Result: |
| // - the value of each component variables are different from the initiated |
| /////////////////////////////////////////////////////////// |
| testcase tc_EPTF_HostAdmin_Base_Test_update() runs on EPTF_HostAdmin_Base_Test_CT { |
| |
| timer t; |
| var EPTF_IntegerList vl_temp; |
| |
| //f_EPTF_Base_init_CT("test-InitMeasInterface"); |
| f_EPTF_HostAdmin_Base_init_CT("test"); |
| t.start(5.0); |
| t.timeout; |
| |
| for(var integer i := 0; i < 1000; i := i + 1) { |
| vl_temp[i] := i; |
| } |
| |
| f_EPTF_HostAdmin_Base_update(); |
| t.start(5.0); |
| t.timeout; |
| f_EPTF_HostAdmin_Base_update(); |
| |
| if(f_EPTF_HostAdmin_Base_getNumCPUs() > 0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getNumCPUs(), ", expected: >0"); |
| setverdict(fail); |
| } |
| |
| if(f_EPTF_HostAdmin_Base_getPhysicalMemory() > 0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getPhysicalMemory(), ", expected: >0"); |
| setverdict(fail); |
| } |
| |
| if(f_EPTF_HostAdmin_Base_getTesterHostLoad() >= 0.0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getTesterHostLoad(), ", expected: >=0.0"); |
| setverdict(fail); |
| } |
| |
| |
| for (var integer i := 0; i < f_EPTF_HostAdmin_Base_getNumCPUs(); i := i + 1) { |
| if(f_EPTF_HostAdmin_Base_getCPULoads(i) >= 0.0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getCPULoads(i), ", expected: >=0.0"); |
| setverdict(fail); |
| } |
| } |
| |
| if(f_EPTF_HostAdmin_Base_getFreeMemory() >= 0) { |
| setverdict(pass); |
| } else { |
| log("Error: wrong initiated value: ", f_EPTF_HostAdmin_Base_getFreeMemory(), ", expected: >=0"); |
| setverdict(fail); |
| } |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_EPTF_HostAdmin_Base_Test_Process_CPULoad |
| // |
| // Purpose: |
| // to test f_EPTF_HostAdmin_Base_getProcessCpuLoad() function |
| // |
| // Requirement: |
| // - |
| // |
| // Action: |
| // - |
| // |
| // Expected Result: |
| // - |
| /////////////////////////////////////////////////////////// |
| testcase tc_EPTF_HostAdmin_Test_Process_CPULoad() runs on EPTF_HostAdmin_Test_Process_CPULoad_Server_CT { |
| |
| f_EPTF_HostAdmin_Test_Process_CPULoad_Server_init_CT("Process_CPULoad"); |
| |
| var float vl_targetLoad := 300.0; |
| var float vl_tolerance := 70.0; |
| |
| |
| var EPTF_HostAdmin_Test_Process_CPULoad_CT vl_procCompRef := EPTF_HostAdmin_Test_Process_CPULoad_CT.create; |
| vl_procCompRef.start(f_EPTF_HostAdmin_Test_Process_CPULoad_proc_behavior("proc", vl_targetLoad, 60000)); |
| |
| timer t_procWait := 20.0; |
| t_procWait.start; |
| |
| timer t_dsReady := 0.0, t_dsWait := 10.0; |
| t_dsReady.start; t_dsWait.start; |
| |
| alt { |
| [v_dsHostAdminReady == true] t_dsReady.timeout {}; |
| [] t_dsWait.timeout { |
| setverdict(inconc, "HostAdmin DS Ready not received in time!"); |
| f_EPTF_Base_stopAll(none); |
| } |
| } |
| action("*** INIT *** ", v_dsHostAdminReady); |
| |
| |
| t_procWait.timeout; |
| |
| var EPTF_Var_DirectContent vl_dataValue; |
| if ( 0 != f_EPTF_DataSource_getDataValue( |
| pl_dataValue := vl_dataValue, |
| pl_source := c_HostAdminServer_DataSource_sourceId, |
| pl_element := c_HostAdminServer_dataElementCpuLoad, |
| pl_params := { { |
| c_HostAdminServer_paramNameSelfName, "proc"&int2str(float2int(vl_targetLoad)) |
| } } |
| ) ) { |
| setverdict(inconc, "DataElement not found for Process CPU Load: ", c_HostAdmin_dataElementProcCPULoad); |
| f_EPTF_Base_stopAll(none); |
| } |
| |
| var float vl_measuredProcLoad := vl_dataValue.floatVal; |
| |
| if ((vl_measuredProcLoad - vl_targetLoad)*(vl_measuredProcLoad - vl_targetLoad) > vl_tolerance*vl_tolerance) { |
| setverdict(fail, "Measured CPU Load for Process Not Acceptable! Should be: ", vl_targetLoad, "! Measured is: ", vl_measuredProcLoad); |
| f_EPTF_Base_stopAll(none); |
| } |
| |
| setverdict(pass); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| |
| |
| |
| |
| |
| function f_EPTF_HostAdmin_Test_DataSourceClientReady( |
| in charstring pl_source, |
| in charstring pl_ptcName) |
| runs on SYSTEM_CT{ |
| action("Ready received"); |
| v_startBecauseDSIsReady := v_startBecauseDSIsReady + 1; |
| } |
| |
| |
| |
| function f_EPTF_HostAdmin_Test_requestDataAndCheck( in charstring pl_elementName, |
| in EPTF_CharstringList pl_result, |
| in EPTF_DataSource_Params pl_params := {}, |
| in boolean pl_dataElement := false, |
| in charstring pl_dataElementResult := "", |
| in boolean pl_negateResult := false, |
| inout EPTF_CharstringList pl_iteratorOut, |
| in charstring pl_dataProviderName := c_HostAdmin_DataSource_sourceId |
| ) runs on SYSTEM_CT { |
| |
| var charstring vl_varName; |
| var integer vl_retCode := 0; |
| vl_retCode :=f_EPTF_DataSource_getData( |
| pl_dataVarName := vl_varName, |
| pl_source := pl_dataProviderName, |
| pl_ptcName := "", |
| pl_element := pl_elementName, |
| pl_params := pl_params |
| ); |
| |
| if (pl_dataElement == false){ |
| if (0!=vl_retCode) { |
| setverdict(fail,"Cannot get iterator for dataSource := "&pl_dataProviderName&", ptcName :=", f_EPTF_Base_selfName() & ", element := " & pl_elementName); |
| return; |
| }; |
| |
| var integer vl_varIdx := f_EPTF_Var_getId(vl_varName); |
| var EPTF_CharstringList vl_iList := f_EPTF_Var_getCharstringlistValue(vl_varIdx); |
| pl_iteratorOut := vl_iList; |
| if ((pl_negateResult == false and sizeof(vl_iList) != sizeof(pl_result)) or (pl_negateResult == true and sizeof(vl_iList) == sizeof(pl_result))){ |
| setverdict(fail, pl_elementName & ": Result is: " & log2str(pl_result) & " instead of "& log2str(vl_iList)); |
| return; |
| } |
| |
| var integer vl_bool := 0; |
| |
| for(var integer i := 0; i < sizeof(vl_iList); i := i + 1){ |
| vl_bool := 0; |
| |
| for(var integer j := 0; j < sizeof(pl_result); j := j + 1){ |
| if (vl_iList[i] == pl_result[j]){ |
| vl_bool := vl_bool + 1; |
| continue; |
| } |
| |
| } |
| if(vl_bool != 1){ |
| for(var integer k := 0; k < sizeof(vl_iList); k := k + 1){ |
| if(vl_iList[i] == vl_iList[k]){ vl_bool := vl_bool - 1;} |
| } |
| if((vl_bool != 0 and pl_negateResult == false) or (vl_bool == 0 and pl_negateResult == true)){ |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_iList) & " instead of "& log2str(pl_result)); |
| return; |
| } |
| |
| } |
| } |
| } else { |
| if (0!=vl_retCode) { |
| setverdict(fail,"Cannot get dataElement for dataSource := "&pl_dataProviderName&", ptcName :=", f_EPTF_Base_selfName() & ", element := " & pl_elementName); |
| return; |
| }; |
| |
| var integer vl_varIdx := f_EPTF_Var_getId(vl_varName); |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getContent(vl_varIdx, vl_content); |
| if(pl_elementName == "ResetMinMaxAvgCPULoad"){action("CONTENT"&log2str(vl_content));} |
| if(ischosen(vl_content.floatVal)){ |
| if((pl_negateResult and pl_dataElementResult == log2str(vl_content.floatVal)) or (pl_negateResult == false and pl_dataElementResult != log2str(vl_content.floatVal))) { |
| action("FLOATVAL: "&log2str(vl_content.floatVal)); |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_content.floatVal) & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| if(ischosen(vl_content.charstringVal)){ |
| if((pl_negateResult and pl_dataElementResult == log2str(vl_content.charstringVal)) or (pl_negateResult == false and pl_dataElementResult != log2str(vl_content.charstringVal))){ |
| setverdict(fail,pl_elementName & ": Result is: " & vl_content.charstringVal & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| if(ischosen(vl_content.intVal)){ |
| if((pl_negateResult and pl_dataElementResult == log2str(vl_content.intVal)) or (pl_negateResult == false and pl_dataElementResult != log2str(vl_content.intVal))){ |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_content.intVal) & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| if(ischosen(vl_content.boolVal)){ |
| if((pl_negateResult and pl_dataElementResult == log2str(vl_content.boolVal)) or (pl_negateResult == false and pl_dataElementResult != log2str(vl_content.boolVal))){ |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_content.boolVal) & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| if(ischosen(vl_content.statusLEDVal)){ |
| if((pl_negateResult and pl_dataElementResult == log2str(vl_content.statusLEDVal)) or (pl_negateResult == false and pl_dataElementResult != log2str(vl_content.statusLEDVal))){ |
| setverdict(fail,pl_elementName & ": Result is: " & log2str(vl_content.statusLEDVal) & " instead of "& pl_dataElementResult); |
| return; |
| } |
| } |
| } |
| } |
| |
| |
| type component SYSTEM_CT extends EPTF_UIHandler_CT, EPTF_Var_CT |
| { |
| var integer v_startBecauseDSIsReady := 0; |
| } |
| |
| testcase tc_EPTF_HostAdmin_dataSource_test() |
| runs on SYSTEM_CT |
| { |
| f_EPTF_DataSource_init_CT("MTC"); |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_HostAdmin_Test_DataSourceClientReady )); |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_UIHandler_clearGUI(); |
| f_EPTF_UIHandler_addWindow(); |
| f_EPTF_UIHandler_addMainTabbox(); |
| |
| if(sizeof(tsp_uiDemoHostList) == 0) { |
| var EPTF_HostAdmin_CT vl_adm := EPTF_HostAdmin_CT.create(-, tsp_demoHost); |
| vl_adm.start(f_EPTF_HostAdmin_test_behavior(c_hostAdmin_name, tsp_demoHost, mtc)); |
| } else { |
| for(var integer i:=0; i<sizeof(tsp_uiDemoHostList); i:=i+1) { |
| var EPTF_HostAdmin_CT vl_adm := EPTF_HostAdmin_CT.create(-, tsp_uiDemoHostList[i]); |
| vl_adm.start( |
| f_EPTF_HostAdmin_test_behavior(c_hostAdmin_name&"."&int2str(i), |
| tsp_uiDemoHostList[i], mtc)); |
| timer T:=0.1; |
| T.start;T.timeout; |
| } |
| } |
| |
| timer T_guard, T_alt; |
| T_guard.start( 100.0 ); |
| T_alt.start( 0.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| f_EPTF_Base_stopAll(); |
| } |
| [v_startBecauseDSIsReady > 0] T_alt.timeout{} |
| }; |
| |
| |
| timer T_wait; |
| T_wait.start( 15.0 ); |
| T_wait.timeout; |
| |
| var EPTF_CharstringList vl_pidList, vl_pidListNotUsed; |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementHostCPULoad, { }, {}, true, "0.000000", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_iteratorProcesses, { }, {}, false, "", true, vl_pidList); |
| if(sizeof(vl_pidList) > 0){ |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementProcName, { }, {{c_HostAdmin_paramNameProcID, vl_pidList[0]}}, true, "", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementProcCPULoad, { }, {{c_HostAdmin_paramNameProcID, vl_pidList[0]}}, true, "89.568000", false, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementProcMEMUsage, { }, {{c_HostAdmin_paramNameProcID, vl_pidList[0]}}, true, "123", false, vl_pidListNotUsed); |
| } |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_iteratorCPUs, { }, {}, false, "", true, vl_pidListNotUsed); |
| if(sizeof(vl_pidListNotUsed) > 0){ |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementCPULoad, { }, {{c_HostAdmin_paramNameCPU_ID, vl_pidListNotUsed[0]}}, true, "12.345678", false, vl_pidListNotUsed); |
| } |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementHostNumCPUs, { }, {}, true, "0", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementHostPhysicalMemory, { }, {}, true, "0", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementHostFreeMemory, { }, {}, true, "0", true, vl_pidListNotUsed); |
| |
| |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementHostName, { }, {}, true, "0", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementIPv4Addr, { }, {}, true, "0", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementIPv6Addr, { }, {}, true, "0", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementMinCPULoad, { }, {}, true, "0.000000", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementMaxCPULoad, { }, {}, true, "0.000000", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementAvgCPULoad, { }, {}, true, "0.000000", true, vl_pidListNotUsed); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck( c_HostAdmin_dataElementResetMinMaxAvgCPULoad, { }, {}, true, "0", false, vl_pidListNotUsed); |
| |
| f_EPTF_Base_cleanup_CT(); |
| setverdict(pass); |
| } |
| |
| testcase tc_EPTF_HostAdmin_customGUI_test() |
| runs on SYSTEM_CT |
| { |
| f_EPTF_DataSource_init_CT("MTC"); |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_HostAdmin_Test_DataSourceClientReady )); |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_UIHandler_clearGUI(); |
| f_EPTF_UIHandler_addWindow(); |
| |
| if(sizeof(tsp_uiDemoHostList) == 0) { |
| var EPTF_HostAdmin_CT vl_adm := EPTF_HostAdmin_CT.create(-, tsp_demoHost); |
| vl_adm.start(f_EPTF_HostAdmin_behavior(c_hostAdmin_name, tsp_demoHost, mtc)); |
| } else { |
| for(var integer i:=0; i<sizeof(tsp_uiDemoHostList); i:=i+1) { |
| var EPTF_HostAdmin_CT vl_adm := EPTF_HostAdmin_CT.create(-, tsp_uiDemoHostList[i]); |
| vl_adm.start( |
| f_EPTF_HostAdmin_behavior(c_hostAdmin_name&"."&int2str(i), |
| tsp_uiDemoHostList[i], mtc)); |
| timer T:=0.1; |
| T.start;T.timeout; |
| } |
| } |
| |
| timer T_guard, T_alt; |
| T_guard.start( 100.0 ); |
| T_alt.start( 0.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| f_EPTF_Base_stopAll(); |
| } |
| [v_startBecauseDSIsReady > 0] T_alt.timeout{} |
| }; |
| |
| f_EPTF_UIHandler_createGUIFromFile(tsp_HostAdmin_guiXmlName, tsp_EPTF_GUI_Main_Window_WidgetId); |
| |
| timer T_wait; |
| T_wait.start( 15.0 ); |
| T_wait.timeout; |
| |
| f_EPTF_Base_cleanup_CT(); |
| setverdict(pass); |
| } |
| |
| |
| type component HostAdmin_customGUI_test_Manual_CT extends SYSTEM_CT, EPTF_HostAdminServer_CT { |
| } |
| |
| function f_EPTF_HostAdmin_customGUI_test_dataSourceHandler( |
| out charstring pl_dataVarName, |
| in charstring pl_source, |
| in charstring pl_ptcName, |
| in charstring pl_element, |
| in EPTF_DataSource_Params pl_params |
| ) runs on HostAdmin_customGUI_test_Manual_CT return integer { |
| pl_dataVarName := pl_element; |
| return 0; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_EPTF_HostAdmin_customGUI_test_Manual |
| // |
| // Purpose: |
| // To test if NaN problem occurs in GUI: |
| // @2012.07.20 14:18:08:126 |
| // Error: Put request failed on HostAdmin.seasc0774.CAI3G_Pool1_0_Logger.allProcessStats.CpuLoadChart.memUsage widget with argument: 1342786684.291824/nan |
| // |
| // It starts 10 dummy PTCs and creates a custom gui from the hostadmin (genapp) xml. |
| // Runs until killed by user |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_EPTF_HostAdmin_customGUI_test_Manual() |
| runs on HostAdmin_customGUI_test_Manual_CT |
| { |
| f_EPTF_DataSource_init_CT("MTC"); |
| f_EPTF_HostAdminServer_init_CT("MTC",self); |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_HostAdmin_Test_DataSourceClientReady )); |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_UIHandler_clearGUI(); |
| f_EPTF_UIHandler_addWindow(); |
| |
| var integer vl_numberOfPTCs := tsp_customGUI_test_Manual_numberOfPTCs; |
| |
| for(var integer i:=0; i<vl_numberOfPTCs; i:=i+1) { |
| var EPTF_Base_CT vl_dumyComp := EPTF_Base_CT.create; |
| // var EPTF_Base_CT vl_dumyComp := EPTF_Base_CT.create(-,"esekits1066"); |
| vl_dumyComp.start(f_demo_load("esekits1066_dummy"&int2str(i),0.0+0.2*int2float(i)/int2float(vl_numberOfPTCs))); |
| } |
| |
| // create a dataSource variable: |
| var integer vl_idx; |
| f_EPTF_Var_newCharstring("StringData","<iframe width=""100%"" height=""800px"" src=""http://internal.ericsson.com/page/hub_inside/support/rd/tools/Titan/index.jsp""></iframe>",vl_idx); |
| f_EPTF_DataSourceClient_registerData("HostAdminTest",f_EPTF_Base_selfName(),refers(f_EPTF_HostAdmin_customGUI_test_dataSourceHandler),self); |
| |
| |
| |
| timer T_guard, T_alt; |
| T_guard.start( 100.0 ); |
| T_alt.start( 2.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| f_EPTF_Base_stopAll(); |
| } |
| [v_startBecauseDSIsReady > 0] T_alt.timeout{} |
| }; |
| |
| f_EPTF_UIHandler_createGUIFromFile("gui_genapp_hostadmin_tabpanel.xml", tsp_EPTF_GUI_Main_Window_WidgetId); |
| |
| timer T_wait; |
| T_wait.start( 1500.0 ); |
| T_wait.timeout; |
| |
| f_EPTF_Base_wait4Shutdown(); |
| f_EPTF_Base_cleanup_CT(); |
| setverdict(pass); |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_HostAdmin_test_behavior |
| // |
| // Purpose: |
| // Main behavior function for EPTF_HostAdmin - slightly modified - |
| // it will always report 89,568 load and mem usage of 123 kb for all processes. |
| // |
| // Parameters: |
| // pl_selfName - *charstring* - name of the component |
| // pl_hostName - *charstring* - host name |
| // pl_dataSource_Ref - <EPTF_DataSource_CT> - datasource component reference |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_HostAdmin_test_behavior(in charstring pl_selfName, in charstring pl_hostName := "", in EPTF_DataSource_CT pl_dataSource_Ref:= null) runs on EPTF_HostAdmin_CT |
| { |
| timer T_getLoad := tsp_EPTF_HostAdmin_loadMeasurementRefreshTime * 0.1; |
| var integer i; |
| |
| // Init meas interface |
| f_EPTF_HostAdmin_init_CT(pl_selfName, pl_hostName, pl_dataSource_Ref); |
| action(f_EPTF_Base_selfName()&", NofProcesses1: "&log2str(v_EPTF_HostAdmin_processStatDB.nofProcesses)); |
| f_EPTF_Var_refreshContent(v_EPTF_HostAdmin_numCPUs_k); |
| f_EPTF_Var_refreshContent(v_EPTF_HostAdmin_physicalMemory_k); |
| for(i:=0; i<v_EPTF_HostAdmin_numCPUs; i:=i+1) { |
| f_EPTF_Var_removeGuardFn(v_EPTF_HostAdmin_CPULoads_k[i], {refers(f_EPTF_HostAdmin_VarGuardFn), {}}); |
| } |
| |
| action(f_EPTF_Base_selfName()&", NofProcesses2: "&log2str(v_EPTF_HostAdmin_processStatDB.nofProcesses)); |
| |
| T_getLoad.start; |
| |
| alt |
| { |
| [] T_getLoad.timeout |
| { |
| f_EPTF_HostAdmin_Base_update(); |
| |
| f_EPTF_Var_refreshContent(v_EPTF_HostAdmin_testerHostLoad_k); |
| for(i:=0; i<v_EPTF_HostAdmin_numCPUs; i:=i+1) { |
| //f_EPTF_Var_refreshContent(v_EPTF_HostAdmin_CPULoads_k[i]); |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_CPULoads_k[i], {floatVal:=12.345678}); |
| } |
| f_EPTF_Var_refreshContent(v_EPTF_HostAdmin_freeMemory_k); |
| |
| for(i:=0; i<v_EPTF_HostAdmin_processStatDB.nofProcesses; i:=i+1) { |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_processStatDB.processes[i].cpu_k, |
| {floatVal:=89.568}); |
| // Here the original code was modified in order to test the value of the datasource |
| f_EPTF_Var_adjustContent(v_EPTF_HostAdmin_processStatDB.processes[i].mem_k, |
| {intVal:=123}); |
| } |
| |
| T_getLoad.start; |
| repeat; |
| } |
| } // alt |
| |
| action(f_EPTF_Base_selfName()&", NofProcesses3: "&log2str(v_EPTF_HostAdmin_processStatDB.nofProcesses)); |
| f_EPTF_Base_cleanup_CT(); |
| } |
| |
| |
| //================================================================ |
| // f_EPTF_HostAdmin_Test_wrongDataRequest |
| //================================================================ |
| function f_EPTF_HostAdmin_Test_wrongDataRequest(in charstring pl_elementName, |
| in EPTF_DataSource_Params pl_params := {}, |
| in charstring pl_dataProviderName := c_HostAdmin_DataSource_sourceId) |
| runs on SYSTEM_CT |
| { |
| f_EPTF_DataSource_init_CT("MTC"); |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_HostAdmin_Test_DataSourceClientReady )); |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_UIHandler_clearGUI(); |
| f_EPTF_UIHandler_addWindow(); |
| f_EPTF_UIHandler_addMainTabbox(); |
| |
| if(sizeof(tsp_uiDemoHostList) == 0) { |
| var EPTF_HostAdmin_CT vl_adm := EPTF_HostAdmin_CT.create(-, tsp_demoHost); |
| vl_adm.start(f_EPTF_HostAdmin_test_behavior(c_hostAdmin_name, tsp_demoHost, mtc)); |
| } else { |
| for(var integer i:=0; i<sizeof(tsp_uiDemoHostList); i:=i+1) { |
| var EPTF_HostAdmin_CT vl_adm := EPTF_HostAdmin_CT.create(-, tsp_uiDemoHostList[i]); |
| vl_adm.start( |
| f_EPTF_HostAdmin_test_behavior(c_hostAdmin_name&"."&int2str(i), |
| tsp_uiDemoHostList[i], mtc)); |
| timer T:=0.1; |
| T.start;T.timeout; |
| } |
| } |
| |
| timer T_guard, T_alt; |
| T_guard.start( 100.0 ); |
| T_alt.start( 0.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| f_EPTF_Base_stopAll(); |
| } |
| [v_startBecauseDSIsReady > 0] T_alt.timeout{} |
| }; |
| |
| //Send wrong entitygroup name - kene olyan is, ahol maga a nev van elcseszve |
| |
| var charstring vl_varName; |
| |
| var integer vl_retCode := 0; |
| vl_retCode :=f_EPTF_DataSource_getData( |
| pl_dataVarName := vl_varName, |
| pl_source := pl_dataProviderName, |
| pl_ptcName := "", |
| pl_element := pl_elementName, |
| pl_params := pl_params |
| ); |
| |
| if (0!=vl_retCode) { |
| setverdict(pass, "DataSource query failed as expected with wrong data, dataSource := "&pl_dataProviderName& ", element := " & pl_elementName); |
| }else |
| { |
| setverdict(fail, "DataSource query was succesfull but it shouldn't have been with these values , |
| dataSource := "&pl_dataProviderName& ", element := " & pl_elementName& ", params := "&log2str(pl_params)); |
| } |
| |
| timer T_g2; |
| T_g2.start( 2.0 ); |
| T_g2.timeout; |
| f_EPTF_Base_cleanup_CT(); |
| |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongIteratorProcesses |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Iterator: c_HostAdmin_iteratorProcesses |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongIteratorProcesses() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_iteratorProcesses, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementHostCPULoad |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementHostCPULoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementHostCPULoad() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementHostCPULoad, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementProcName1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementProcName |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementProcName1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementProcName, {}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementProcName2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementProcName |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementProcName2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementProcName, {{c_HostAdmin_paramNameProcID,"21"}, {"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementProcCPULoad1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementProcCPULoad |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementProcCPULoad1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementProcCPULoad, {}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementProcCPULoad2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementProcCPULoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementProcCPULoad2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementProcCPULoad, {{c_HostAdmin_paramNameProcID,"21"}, {"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementProcMEMUsage1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementProcMEMUsage |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementProcMEMUsage1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementProcName, {}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementProcMEMUsage2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementProcMEMUsage |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementProcMEMUsage2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementProcMEMUsage, {{c_HostAdmin_paramNameProcID,"21"}, {"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongIteratorCPUs |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_iteratorCPUs |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongIteratorCPUs() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_iteratorCPUs, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementCPULoad1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementCPULoad |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementCPULoad1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementCPULoad, {}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementCPULoad2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementCPULoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementCPULoad2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementCPULoad, {{c_HostAdmin_paramNameCPU_ID,"0"}, {"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementHostNumCPUs |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementHostNumCPUs |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementHostNumCPUs() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementHostNumCPUs, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementHostPhysicalMemory |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementHostPhysicalMemory |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementHostPhysicalMemory() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementHostPhysicalMemory, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementHostFreeMemory |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementHostFreeMemory |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementHostFreeMemory() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementHostFreeMemory, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementHostName |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementHostName |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementHostName() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementHostName, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementIPv4Addr |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementIPv4Addr |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementIPv4Addr() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementIPv4Addr, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementIPv6Addr |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementIPv6Addr |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementIPv6Addr() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementIPv6Addr, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementMinCPULoad |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementMinCPULoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementMinCPULoad() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementMinCPULoad, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementMaxCPULoad |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementMaxCPULoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementMaxCPULoad() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementMaxCPULoad, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementAvgCPULoad |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementAvgCPULoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementAvgCPULoad() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementAvgCPULoad, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdmin_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdmin with this wrong request: |
| // Data Element: c_HostAdmin_dataElementResetMinMaxAvgCPULoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdmin_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdmin_dataElementResetMinMaxAvgCPULoad, {{"nonexistent", "DefaultEGrp"}}); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| group HostAdminServer { |
| modulepar charstring tsp_HostAdmin_DS_guiXmlName := "gui.xml"; |
| modulepar float tsp_tolerancePercentage := 20.0; |
| modulepar HostLoadProcCfgList tsp_StartProcessesWithLoad := { |
| { |
| hostName := omit, |
| desiredLoad := 0.10 |
| }, |
| { |
| hostName := omit, |
| desiredLoad := 0.50 |
| } |
| |
| } |
| |
| type component SYSTEM2_CT extends EPTF_UIHandler_CT, EPTF_HostAdminServer_CT, SYSTEM_CT |
| { |
| } |
| |
| type record HostLoadProcCfg { |
| charstring hostName optional, |
| float desiredLoad |
| } |
| type record of HostLoadProcCfg HostLoadProcCfgList |
| |
| testcase tc_HostAdminServer_DataTestTroughVariables() |
| runs on SYSTEM2_CT |
| { |
| var integer i := 0; |
| f_EPTF_HostAdminServer_init_CT("MTC", mtc); |
| |
| for(i:=0;i<lengthof(tsp_StartProcessesWithLoad);i:=i+1) { |
| var EPTF_Base_CT vl_load; |
| if(ispresent(tsp_StartProcessesWithLoad[i].hostName)) { |
| var charstring vl_bugfix := tsp_StartProcessesWithLoad[i].hostName; // TITAN 1.8.pl6 bug, see HO69261 |
| vl_load := EPTF_Base_CT.create(-, vl_bugfix); |
| } else { |
| vl_load := EPTF_Base_CT.create; |
| } |
| vl_load.start(f_demo_load("load_"&int2str(i), tsp_StartProcessesWithLoad[i].desiredLoad)); |
| } |
| |
| timer T2 := tsp_demoInterval; |
| T2.start; |
| T2.timeout; |
| |
| f_checkVariables(); |
| |
| f_EPTF_Base_stop(pass); |
| } |
| |
| testcase tc_HostAdminServer_DataTestTroughVariables_WithGUI() |
| runs on SYSTEM2_CT |
| { |
| var integer i := 0; |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_UIHandler_clearGUI(); |
| |
| f_EPTF_HostAdminServer_init_CT("MTC", mtc); |
| |
| for(i:=0;i<lengthof(tsp_StartProcessesWithLoad);i:=i+1) { |
| var EPTF_Base_CT vl_load; |
| if(ispresent(tsp_StartProcessesWithLoad[i].hostName)) { |
| var charstring vl_bugfix := tsp_StartProcessesWithLoad[i].hostName; // TITAN 1.8.pl6 bug, see HO69261 |
| vl_load := EPTF_Base_CT.create(-, vl_bugfix); |
| } else { |
| vl_load := EPTF_Base_CT.create; |
| } |
| vl_load.start(f_demo_load("load_"&int2str(i), tsp_StartProcessesWithLoad[i].desiredLoad)); |
| } |
| |
| timer T1 := 5.0; |
| T1.start; |
| T1.timeout; |
| |
| f_EPTF_UIHandler_createGUIFromFile(tsp_HostAdmin_DS_guiXmlName); |
| |
| timer T2 := tsp_demoInterval; |
| T2.start; |
| T2.timeout; |
| |
| f_checkVariables(); |
| |
| f_EPTF_Base_stop(pass); |
| } |
| |
| testcase tc_HostAdminServer_DataSourceTest() |
| runs on SYSTEM2_CT |
| { |
| var integer i := 0; |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_UIHandler_clearGUI(); |
| |
| f_EPTF_HostAdminServer_init_CT("MTC", mtc); |
| |
| for(i:=0;i<lengthof(tsp_StartProcessesWithLoad);i:=i+1) { |
| var EPTF_Base_CT vl_load; |
| if(ispresent(tsp_StartProcessesWithLoad[i].hostName)) { |
| var charstring vl_bugfix := tsp_StartProcessesWithLoad[i].hostName; // TITAN 1.8.pl6 bug, see HO69261 |
| vl_load := EPTF_Base_CT.create(-, vl_bugfix); |
| } else { |
| vl_load := EPTF_Base_CT.create; |
| } |
| vl_load.start(f_demo_load("load_"&int2str(i), tsp_StartProcessesWithLoad[i].desiredLoad)); |
| } |
| |
| timer T2 := tsp_demoInterval; |
| T2.start; |
| T2.timeout; |
| |
| var EPTF_CharstringList vl_iteratorOut, vl_iteratorOutHost, vl_iteratorOutCPU, vl_iteratorOutProc, vl_iteratorOutProcIdx; |
| //FIXME: check if vl_iteratorOut is used correctly and check the function f_EPTF_HostAdmin_Test_requestDataAndCheck return correctly |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_iteratorProcessSortOptionList, { "EPTF SelfName", "CPU Load", "Memory Usage", "Unsorted" }, {}, false, "", false, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_iteratorHosts, { }, {}, false, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_iteratorProcessNames, { }, {}, false, "", true, vl_iteratorOutProc, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_iteratorProcessesOnHost, { }, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, false, "", true, vl_iteratorOutProcIdx, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementProcessSortOption, {}, {}, true, log2str(c_EPTF_HostAdmin_PDUSortByStr[1]), false, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementNofHosts, {}, {}, true, "1", false, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementPhysicalMem, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementPhysicalMemHRF, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementFreeMem, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementFreeMemHRF, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_iteratorCpus, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, false, "", true, vl_iteratorOutCPU, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementCpuLoad, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementPerCpuLoad, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]},{c_HostAdminServer_paramNameCpuIdx,vl_iteratorOutCPU[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementSelfName, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]},{c_HostAdminServer_paramNameProcessIdx,vl_iteratorOutProcIdx[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementHostName, {}, {{c_HostAdminServer_paramNameSelfName,vl_iteratorOutProc[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementPID, {}, {{c_HostAdminServer_paramNameSelfName,vl_iteratorOutProc[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementMemUsage, {}, {{c_HostAdminServer_paramNameSelfName,vl_iteratorOutProc[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementMemUsageHRF, {}, {{c_HostAdminServer_paramNameSelfName,vl_iteratorOutProc[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| |
| // f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementSelfName, {}, {{c_HostAdminServer_paramNameSelfName, vl_iteratorOutProc[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| // f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementHostName, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]},{c_HostAdminServer_paramNameProcessIdx,vl_iteratorOutProcIdx[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementPID, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]},{c_HostAdminServer_paramNameProcessIdx,vl_iteratorOutProcIdx[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementMemUsage, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]},{c_HostAdminServer_paramNameProcessIdx,vl_iteratorOutProcIdx[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementMemUsageHRF, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]},{c_HostAdminServer_paramNameProcessIdx,vl_iteratorOutProcIdx[0]}}, true, "", true, vl_iteratorOutHost, c_HostAdminServer_DataSource_sourceId); |
| |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementIPv4Addr, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementIPv6Addr, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementCpuMin, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementCpuMax, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementCpuAvg, {}, {{c_HostAdminServer_paramNameHostName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| f_EPTF_HostAdmin_Test_requestDataAndCheck(c_HostAdminServer_dataElementResetMinMaxAvgCPULoad, {}, {{c_HostAdminServer_paramNameSelfName, vl_iteratorOutHost[0]}}, true, "", true, vl_iteratorOut, c_HostAdminServer_DataSource_sourceId); |
| |
| f_EPTF_Base_stop(pass); |
| } |
| |
| |
| |
| group MultiHostTest_Manual { |
| |
| function f_HostAdminServer_MultiHostTest_dummyBehaviour(in charstring pl_selfName) runs on EPTF_Base_CT { |
| f_EPTF_Base_init_CT(pl_selfName); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| function f_HostAdminServer_MultiHostTest_hostAdminServerBehaviour(in charstring pl_selfName,in EPTF_DataSource_CT pl_dataSource_compRef) runs on EPTF_HostAdminServer_CT { |
| f_EPTF_HostAdminServer_init_CT(pl_selfName, pl_dataSource_compRef); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| function f_HostAdminServer_UIHandlerBehaviour(in charstring pl_selfName) |
| runs on EPTF_UIHandler_CT |
| { |
| f_EPTF_UIHandler_init_CT(pl_selfName, true); |
| f_EPTF_UIHandler_clearGUI(); |
| |
| |
| var EPTF_Base_CT vl_dumyComp := EPTF_Base_CT.create(-,"esekits1066"); |
| vl_dumyComp.start(f_HostAdminServer_MultiHostTest_dummyBehaviour("esekits1066_dummy")); |
| |
| |
| var EPTF_HostAdminServer_CT vl_hostAdminServer := EPTF_HostAdminServer_CT.create(-,"esekits1066"); |
| vl_hostAdminServer.start(f_HostAdminServer_MultiHostTest_hostAdminServerBehaviour("esekits1066_hostAdminServer", self)); |
| |
| |
| timer T2 := tsp_demoInterval; |
| T2.start; |
| T2.timeout; |
| |
| f_EPTF_Base_stopAll(pass); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_MultiHostTest |
| // |
| // Purpose: |
| // This is a manual test!!! |
| // It tests if the TR HP82163 is corrected. |
| // |
| // It starts an UIHandler component on host esekits1069 |
| // That component starts a dummy component on esekits1066 |
| // After this two component is started on different hosts |
| // the hostadminServer is started on esekits1066. |
| // Before the correction there was an unknown host (esekits1069) |
| // among the allComponentInfo requested from Base, which resulted |
| // in a crash of the hostadminServer. After the correction the test should pass. |
| // |
| // To run the testcase: |
| // Build the project on esekits1069 (Terminal 1) |
| // Start the RTG with the correct port (modify the CFG accordingly) if you like |
| // |
| // On esekits1069 (Terminal 1): |
| // mctr_cli /vobs/ttcn/TCC_Common/Libraries/EPTF_Core_Library_CNL113512/test/HostAdmin/EPTF_HostAdmin_Test.cfg |
| // |
| // On esekits1069 (Terminal 2): |
| // ./EPTF_HostAdmin_demo esekits1069 <portNo> |
| // <portNo> is the port number printed by mctr_cli |
| // ./EPTF_HostAdmin_demo is the name of the compiled executable |
| // |
| // then on esekits1066 (Terminal 3): |
| // ./EPTF_HostAdmin_demo esekits1069 <portNo> |
| // then inside mctr_cli (Terminal 1): |
| // cmtc |
| // smtc EPTF_HostAdmin_Test_Testcases.tc_HostAdminServer_MultiHostTest |
| // Wait until the testcase finishes. Then type |
| // exit |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_MultiHostTest() |
| runs on EPTF_Base_CT |
| { |
| f_EPTF_Base_init_CT("MTC"); |
| |
| var EPTF_UIHandler_CT vl_uiHandler := EPTF_UIHandler_CT.create(-,"esekits1069"); |
| vl_uiHandler.start(f_HostAdminServer_UIHandlerBehaviour("esekits1066_UIHandler")); |
| |
| f_EPTF_Base_wait4Shutdown(); |
| |
| f_EPTF_Base_stop(pass); |
| } |
| |
| |
| } //group MultiHostTest_Manual |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorProcessSortOptionList |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorProcessSortOptionList |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorProcessSortOptionList() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorProcessSortOptionList, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorHosts |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorHosts |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorHosts() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorHosts, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorProcessNames |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorProcessNames |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorProcessNames() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorProcessNames, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorProcessesOnHost |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorProcessesOnHost, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorProcessesOnHost |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorProcessesOnHost, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorProcessesOnHost |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorProcessesOnHost, {{c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorProcessesOnHost |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorProcessesOnHost, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementProcessSortOption |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementProcessSortOption |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementProcessSortOption() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementProcessSortOption, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementNofHosts |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementNofHosts |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementNofHosts() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementNofHosts, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementIPv4Addr |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementIPv4Addr, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementIPv4Addr |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementIPv4Addr, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementIPv4Addr |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementIPv4Addr, {{"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementIPv4Addr |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementIPv4Addr, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementIPv6Addr |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementIPv6Addr, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementIPv6Addr |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementIPv6Addr, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementIPv6Addr |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementIPv6Addr, {{"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementIPv6Addr |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementIPv6Addr, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuMin |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuMin, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuMin |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuMin, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuMin |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuMin, {{"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuMin |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuMin, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuMax |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuMax, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuMax |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuMax, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuMax |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuMax, {{"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuMax |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuMax, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuAvg |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuAvg, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuAvg |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuAvg, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuAvg |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuAvg, {{"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuAvg |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuAvg, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementResetMinMaxAvgCPULoad |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementResetMinMaxAvgCPULoad, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementResetMinMaxAvgCPULoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementResetMinMaxAvgCPULoad, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementResetMinMaxAvgCPULoad |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementResetMinMaxAvgCPULoad, {{"wrong param", "wrong value"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementResetMinMaxAvgCPULoad |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementResetMinMaxAvgCPULoad, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPhysicalMem |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPhysicalMem, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPhysicalMem |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPhysicalMem, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPhysicalMem |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPhysicalMem, { {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPhysicalMem |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPhysicalMem, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPhysicalMemHRF |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPhysicalMemHRF, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPhysicalMemHRF |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPhysicalMemHRF, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPhysicalMemHRF |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPhysicalMemHRF, {{c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPhysicalMemHRF |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPhysicalMemHRF, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementFreeMem |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementFreeMem, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementFreeMem |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementFreeMem, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementFreeMem |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementFreeMem, {{c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementFreeMem |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementFreeMem, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementFreeMemHRF |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementFreeMemHRF, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementFreeMemHRF |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementFreeMemHRF, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementFreeMemHRF |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementFreeMemHRF, { {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementFreeMemHRF |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementFreeMemHRF, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorCpus1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorCpus |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorCpus1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorCpus, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorCpus2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorCpus |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorCpus2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorCpus, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorCpus3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorCpus |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorCpus3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorCpus, { {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongIteratorCpus4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_iteratorCpus |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongIteratorCpus4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_iteratorCpus, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuLoad |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuLoad, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuLoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuLoad, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuLoad |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuLoad, { {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementCpuLoad |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementCpuLoad, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPerCpuLoad |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPerCpuLoad, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPerCpuLoad |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPerCpuLoad, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPerCpuLoad |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPerCpuLoad, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameCpuIdx,"67"}, {c_HostAdminServer_paramNameSelfName,"myselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPerCpuLoad |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPerCpuLoad, { {c_HostAdminServer_paramNameSelfName, "myselfname"}, {c_HostAdminServer_paramNameCpuIdx,"67"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad5 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPerCpuLoad |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad5() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPerCpuLoad, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameCpuIdx,"1"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad6 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPerCpuLoad |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad6() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPerCpuLoad, { {c_HostAdminServer_paramNameHostName, "localhost"}, {c_HostAdminServer_paramNameCpuIdx,"222222222"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementSelfName1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementSelfName |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementSelfName1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementSelfName, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementSelfName2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementSelfName |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementSelfName2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementSelfName, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementSelfName3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementSelfName |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementSelfName3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementSelfName, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameProcessIdx,"67"}, {c_HostAdminServer_paramNameSelfName,"myselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementSelfName4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementSelfName |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementSelfName4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementSelfName, { {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}, {c_HostAdminServer_paramNameProcessIdx,"67"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementSelfName5 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementSelfName |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementSelfName5() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementSelfName, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameProcessIdx,"1"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementSelfName6 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementSelfName |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementSelfName6() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementSelfName, { {c_HostAdminServer_paramNameHostName, "localhost"}, {c_HostAdminServer_paramNameProcessIdx,"222222222222"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementSelfName7 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementSelfName |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementSelfName7() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementSelfName, { {c_HostAdminServer_paramNameSelfName, "localhost"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementHostName1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementHostName |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementHostName1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementHostName, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementHostName2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementHostName |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementHostName2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementHostName, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameProcessIdx,"222222222222"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementHostName3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementHostName |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementHostName3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementHostName, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementHostName4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementHostName |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementHostName4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementHostName, { {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementHostName5 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementHostName |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementHostName5() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementHostName, { {c_HostAdminServer_paramNameHostName, "localhost"}, {c_HostAdminServer_paramNameProcessIdx,"2"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPID1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPID |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPID1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPID, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPID2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPID |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPID2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPID, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameProcessIdx, "8982342342342"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPID3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPID |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPID3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPID, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPID4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPID |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPID4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPID, { {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementPID5 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementPID |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementPID5() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementPID, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameProcessIdx, "8982342342342"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsage |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsage, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsage |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsage, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameProcessIdx, "8982342342342"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsage |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsage, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsage |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsage, { {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage5 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsage |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage5() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsage, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameProcessIdx, "8982342342342"} }, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF1 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsageHRF |
| // Params: too few params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF1() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsageHRF, {}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF2 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsageHRF |
| // Params: too many params |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF2() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsageHRF, {{c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameProcessIdx, "8982"}, {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF3 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsageHRF |
| // Params: wrong param type |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF3() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsageHRF, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF4 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsageHRF |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF4() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsageHRF, { {c_HostAdminServer_paramNameSelfName, "anythingthatcouldbeaselfname"}}, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF5 |
| // |
| // Purpose: |
| // This is a fake negative test case. |
| // It tests the DataSourceClient function of HostAdminServer with this wrong request: |
| // Data Element: c_HostAdminServer_dataElementMemUsageHRF |
| // Params: wrong param value |
| // A proper warning message should appear. |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF5() runs on SYSTEM_CT |
| { |
| f_EPTF_HostAdmin_Test_wrongDataRequest(c_HostAdminServer_dataElementMemUsageHRF, { {c_HostAdminServer_paramNameHostName, "anythingthatcouldbeahostname"}, {c_HostAdminServer_paramNameProcessIdx, "8982342342342"} }, c_HostAdminServer_DataSource_sourceId); |
| } |
| |
| function f_checkVariables() |
| runs on EPTF_HostAdminServer_CT |
| { |
| var EPTF_CharstringList vl_iProcessSortOptionList := f_EPTF_Var_getCharstringlistValue( f_EPTF_Var_getId(c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_iteratorProcessSortOptionList_varName) ); |
| log(" c_HostAdminServer_iteratorProcessSortOptionList_varName: ", vl_iProcessSortOptionList); |
| if(lengthof(vl_iProcessSortOptionList) <= 0 ){ setverdict(fail,"Process Sort Option List is empty. ") } |
| |
| var EPTF_CharstringList vl_iHosts := f_EPTF_Var_getCharstringlistValue( f_EPTF_Var_getId(c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_iteratorHosts_varName) ); |
| log(" c_HostAdminServer_iteratorHosts_varName: ", vl_iHosts); |
| if(lengthof(vl_iHosts) <= 0 ){ setverdict(fail,"Host List is empty. ") } |
| |
| var charstring vl_processSortOption := f_EPTF_Var_getCharstringValue( f_EPTF_Var_getId(c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_dataElementProcessSortOption) ); |
| log(" c_HostAdminServer_dataElementProcessSortOption: ", vl_processSortOption); |
| if(vl_processSortOption == "" ){ setverdict(fail,"Process Sort Option is empty.") } |
| |
| var integer vl_nofHosts := f_EPTF_Var_getIntValue(f_EPTF_Var_getId(c_HostAdminServer_DS_iteratorVar_prefix & c_HostAdminServer_dataElementNofHosts)); |
| log(" c_HostAdminServer_dataElementNofHosts: ",vl_nofHosts); |
| if(lengthof(v_EPTF_HostAdmin_hostDB.hosts) != vl_nofHosts ){ setverdict(fail,"Number of Hosts is not ambivalent.") } |
| if(0 >= vl_nofHosts ){ setverdict(fail,"Number of Hosts is not positive.") } |
| |
| var EPTF_Base_ComponentInfoList vl_compInfoList := f_EPTF_Base_getComponentInfoAll(); |
| for(var integer vl_hostsIdx:=0; vl_hostsIdx < lengthof(v_EPTF_HostAdmin_hostDB.hosts); vl_hostsIdx := vl_hostsIdx + 1) { |
| var charstring vl_prefix := f_EPTF_HostAdminServer_getHostVarNamePrefix(v_EPTF_HostAdmin_hostDB.hosts[vl_hostsIdx].hostName); |
| var integer vl_physicalMem := f_EPTF_Var_getIntValue(f_EPTF_Var_getId(vl_prefix & c_HostAdminServer_dataElementPhysicalMem)); |
| log(" c_HostAdminServer_dataElementPhysicalMem: ",vl_physicalMem); |
| if(0 >= vl_physicalMem ){ setverdict(fail,"Physical Memory is not positive.") } |
| |
| var charstring vl_physicalMemHRF := f_EPTF_Var_getCharstringValue( f_EPTF_Var_getId(vl_prefix & c_HostAdminServer_dataElementPhysicalMemHRF) ); |
| log(" c_HostAdminServer_dataElementPhysicalMemHRF: ", vl_physicalMemHRF); |
| if(vl_physicalMemHRF == "" ){ setverdict(fail,"Physical Memory(Human readable form) is empty.") } |
| |
| var integer vl_freeMem := f_EPTF_Var_getIntValue(f_EPTF_Var_getId(vl_prefix & c_HostAdminServer_dataElementFreeMem)); |
| log(" c_HostAdminServer_dataElementFreeMem: ",vl_freeMem); |
| if(0 >= vl_freeMem ){ setverdict(fail,"Free Memory is not positive.") } |
| |
| var charstring vl_freeMemHRF := f_EPTF_Var_getCharstringValue( f_EPTF_Var_getId(vl_prefix & c_HostAdminServer_dataElementFreeMemHRF) ); |
| log(" c_HostAdminServer_dataElementFreeMemHRF: ", vl_freeMemHRF); |
| if(vl_freeMemHRF == "" ){ setverdict(fail,"Free Memory(Human readable form) is empty.") } |
| |
| var float vl_cpuLoad := f_EPTF_Var_getFloatValue( f_EPTF_Var_getId(vl_prefix & c_HostAdminServer_dataElementCpuLoad) ); |
| log(" c_HostAdminServer_dataElementCpuLoad: ", vl_cpuLoad); |
| if(0.0 >= vl_cpuLoad ){ setverdict(fail,"CPU load is not positive.") } |
| |
| var EPTF_CharstringList vl_iCpus := f_EPTF_Var_getCharstringlistValue( f_EPTF_Var_getId(vl_prefix & c_HostAdminServer_iteratorCpus_varName) ); |
| log(" c_HostAdminServer_iteratorCpus_varName: ", vl_iCpus); |
| if(lengthof(vl_iCpus) <= 0 ){ setverdict(fail,"CPU List is empty. ") } |
| |
| for(var integer vl_idx:=0;vl_idx < lengthof(v_EPTF_HostAdmin_hostDB.hosts[vl_hostsIdx].processStats);vl_idx:=vl_idx+1) { |
| var charstring vl_hostNamePrefix := f_EPTF_HostAdminServer_getHostProcessVarNamePrefix(v_EPTF_HostAdmin_hostDB.hosts[vl_hostsIdx].hostName, int2str(vl_idx)); |
| |
| var charstring vl_selfName := f_EPTF_Var_getCharstringValue( f_EPTF_Var_getId(vl_hostNamePrefix & c_HostAdminServer_dataElementSelfName) ); |
| log(" c_HostAdminServer_dataElementSelfName: ", vl_selfName); |
| if(vl_selfName == ""){ setverdict(fail,"Process SelfName is empty.") } |
| |
| var charstring vl_prefixFromProcessName := f_EPTF_HostAdminServer_getProcessVarNamePrefix(vl_selfName); |
| |
| var EPTF_CharstringList vl_iProcesses := f_EPTF_Var_getCharstringlistValue( f_EPTF_Var_getId(vl_prefix & c_HostAdminServer_iteratorProcessesOnHost_varName) ); |
| log(" c_HostAdminServer_iteratorProcessesOnHost_varName: ", vl_iProcesses); |
| if(lengthof(vl_iProcesses) <= 0 ){ setverdict(fail,"Processes List is empty. ") } |
| |
| var integer vl_PID := f_EPTF_Var_getIntValue(f_EPTF_Var_getId(vl_hostNamePrefix & c_HostAdminServer_dataElementPID)); |
| log(" c_HostAdminServer_dataElementPID: ",vl_PID); |
| if(0 >= vl_PID ){ setverdict(fail,"Process PID is not positive.") } |
| |
| var float vl_cpuLoadP := f_EPTF_Var_getFloatValue( f_EPTF_Var_getId(vl_hostNamePrefix & c_HostAdminServer_dataElementCpuLoad) ); |
| log(" c_HostAdminServer_dataElementCpuLoad: ", vl_cpuLoadP); |
| if(vl_selfName == "load_0"){ if( vl_cpuLoadP < tsp_StartProcessesWithLoad[0].desiredLoad*(100.0-tsp_tolerancePercentage) or vl_cpuLoadP > tsp_StartProcessesWithLoad[0].desiredLoad*(100.0+tsp_tolerancePercentage) ) |
| { setverdict(fail,"The load on the first lgen is wrong: " & log2str(vl_cpuLoadP) & " and should be between " &log2str(tsp_StartProcessesWithLoad[0].desiredLoad*(100.0-tsp_tolerancePercentage)) & " and " & log2str(tsp_StartProcessesWithLoad[0].desiredLoad*(100.0+tsp_tolerancePercentage)) ); } } |
| if(vl_selfName == "load_1"){ if( vl_cpuLoadP < tsp_StartProcessesWithLoad[1].desiredLoad*(100.0-tsp_tolerancePercentage) or vl_cpuLoadP > tsp_StartProcessesWithLoad[1].desiredLoad*(100.0+tsp_tolerancePercentage) ) |
| { setverdict(fail,"The load on the second lgen is wrong: " & log2str(vl_cpuLoadP) & " and should be between " &log2str(tsp_StartProcessesWithLoad[1].desiredLoad*(100.0-tsp_tolerancePercentage)) & " and " & log2str(tsp_StartProcessesWithLoad[1].desiredLoad*(100.0+tsp_tolerancePercentage)) ); } } |
| |
| var integer vl_PIDFP := f_EPTF_Var_getIntValue(f_EPTF_Var_getId(vl_prefixFromProcessName & c_HostAdminServer_dataElementPID)); |
| log(" c_HostAdminServer_dataElementPID: ",vl_PIDFP); |
| if(0 >= vl_PIDFP ){ setverdict(fail,"Process PID is not positive.") } |
| |
| var float vl_cpuLoadPFP := f_EPTF_Var_getFloatValue( f_EPTF_Var_getId(vl_prefixFromProcessName & c_HostAdminServer_dataElementCpuLoad) ); |
| log(" c_HostAdminServer_dataElementCpuLoad: ", vl_cpuLoadPFP); |
| if(vl_selfName == "load_0"){ if( vl_cpuLoadPFP < tsp_StartProcessesWithLoad[0].desiredLoad*(100.0-tsp_tolerancePercentage) or vl_cpuLoadPFP > tsp_StartProcessesWithLoad[0].desiredLoad*(100.0+tsp_tolerancePercentage) ) |
| { setverdict(fail,"The load on the first lgen from process name is wrong: " & log2str(vl_cpuLoadPFP) & " and should be between " &log2str(tsp_StartProcessesWithLoad[0].desiredLoad*(100.0-tsp_tolerancePercentage)) & " and " & log2str(tsp_StartProcessesWithLoad[0].desiredLoad*(100.0+tsp_tolerancePercentage)) ); } } |
| if(vl_selfName == "load_1"){ if( vl_cpuLoadPFP < tsp_StartProcessesWithLoad[1].desiredLoad*(100.0-tsp_tolerancePercentage) or vl_cpuLoadPFP > tsp_StartProcessesWithLoad[1].desiredLoad*(100.0+tsp_tolerancePercentage) ) |
| { setverdict(fail,"The load on the second lgen from process name is wrong: " & log2str(vl_cpuLoadPFP) & " and should be between " &log2str(tsp_StartProcessesWithLoad[1].desiredLoad*(100.0-tsp_tolerancePercentage)) & " and " & log2str(tsp_StartProcessesWithLoad[1].desiredLoad*(100.0+tsp_tolerancePercentage)) ); } } |
| |
| var integer vl_memUsage := f_EPTF_Var_getIntValue(f_EPTF_Var_getId(vl_hostNamePrefix & c_HostAdminServer_dataElementMemUsage)); |
| log(" c_HostAdminServer_dataElementMemUsage: ",vl_memUsage); |
| if(0 >= vl_memUsage ){ setverdict(fail,"Process memory usage is not positive.") } |
| |
| var charstring vl_memUsageHRF := f_EPTF_Var_getCharstringValue( f_EPTF_Var_getId(vl_hostNamePrefix & c_HostAdminServer_dataElementMemUsageHRF) ); |
| log(" c_HostAdminServer_dataElementMemUsageHRF: ", vl_memUsageHRF); |
| if(vl_memUsageHRF == "" ){ setverdict(fail,"Process Memory Usage (Human readable form) is empty.") } |
| |
| var integer vl_memUsageFP := f_EPTF_Var_getIntValue(f_EPTF_Var_getId(vl_prefixFromProcessName & c_HostAdminServer_dataElementMemUsage)); |
| log(" c_HostAdminServer_dataElementMemUsage: ",vl_memUsageFP); |
| if(0 >= vl_memUsageFP ){ setverdict(fail,"Process memory usage from process name is not positive.") } |
| |
| var charstring vl_memUsageHRFFP := f_EPTF_Var_getCharstringValue( f_EPTF_Var_getId(vl_prefixFromProcessName & c_HostAdminServer_dataElementMemUsageHRF) ); |
| log(" c_HostAdminServer_dataElementMemUsageHRF: ", vl_memUsageHRFFP); |
| if(vl_memUsageHRFFP == "" ){ setverdict(fail,"Process Memory Usage (Human readable form) from process name is empty.") } |
| |
| var charstring vl_hostName := f_EPTF_Var_getCharstringValue( f_EPTF_Var_getId(vl_prefixFromProcessName & c_HostAdminServer_dataElementHostName) ); |
| log(" c_HostAdminServer_dataElementHostName: ", vl_hostName); |
| if(vl_hostName == ""){ setverdict(fail,"Host name from process name is empty.") } |
| if(vl_hostName != v_EPTF_HostAdmin_hostDB.hosts[vl_hostsIdx].hostName){ setverdict(fail,"Host name from process name is not the same as expected.") } |
| } |
| |
| |
| |
| for(var integer i:=0; i<lengthof(v_EPTF_HostAdmin_hostDB.hosts[vl_hostsIdx].hostStats.perCpuVarKeys); i:=i+1) { |
| vl_prefix := f_EPTF_HostAdminServer_getCpuVarNamePrefix(v_EPTF_HostAdmin_hostDB.hosts[vl_hostsIdx].hostName, int2str(i)); |
| var float vl_perCpuLoad := f_EPTF_Var_getFloatValue( f_EPTF_Var_getId(vl_prefix & c_HostAdminServer_dataElementPerCpuLoad) ); |
| log(" c_HostAdminServer_dataElementPerCpuLoad: ", vl_perCpuLoad); |
| if(0.0 > vl_perCpuLoad ){ setverdict(fail,"Per CPU load is negative.") } |
| } |
| |
| |
| } |
| } |
| |
| |
| function f_demo_load(in charstring pl_selfName, in float pl_desiredLoad) |
| runs on EPTF_Base_CT |
| { |
| if(pl_desiredLoad > 0.99) { |
| action("desired load is bigger than 0.99, using 0.99"); |
| pl_desiredLoad := 0.99; |
| } |
| |
| f_EPTF_Base_init_CT(pl_selfName); |
| timer T; |
| var integer i; |
| var integer vl_lim := 1000; |
| var float vl_elapsed := 0.0; |
| while(vl_elapsed < 0.1) { |
| vl_lim := vl_lim * 10; |
| T.start(100.0); |
| for(i:=0; i<vl_lim; i:=i+1) { |
| var charstring vl_dummy := log2str(i); |
| } |
| vl_elapsed := T.read; |
| T.stop; |
| } |
| const float cl_timeBase := 0.1; |
| const float cl_requestedRate := 0.5; // setup the rate between requested and original |
| var float vl_idle := 1.0 - pl_desiredLoad; |
| var float vl_idleTime := cl_timeBase * vl_idle; |
| var float vl_idleTimeNext := vl_idleTime; |
| var float vl_loadTime := cl_timeBase * pl_desiredLoad; |
| var float vl_loadPercent := pl_desiredLoad; |
| var float vl_loadFull := 0.0; |
| var float vl_idleFull := 0.0; |
| action("time elapsed for ", vl_lim, " cycles: ", vl_elapsed); |
| vl_lim := float2int((vl_loadTime / vl_elapsed) * int2float(vl_lim)); |
| var integer vl_limOrig := vl_lim; // backup the origin |
| var float vl_idleTimeOrig := vl_idleTime; |
| //action("K.I. - ",log2str("vl_loadTime: ", vl_loadTime, " - vl_idleTime: ", vl_idleTime, " - vl_lim: ", vl_lim )); |
| var integer vl_j :=0; |
| if (pl_desiredLoad==0.0) { |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| T.start(0.0); // start with load |
| alt { |
| []T.timeout { |
| timer T_meas := 100.0; |
| T_meas.start; |
| for(i:=0; i<vl_lim; i:=i+1) { |
| var charstring vl_dummy := log2str(i); |
| } |
| vl_elapsed := T_meas.read; |
| T_meas.stop; |
| var integer vl_limNext := vl_lim; |
| var integer vl_limRequested := vl_lim; |
| vl_idleTimeNext := ((vl_elapsed / pl_desiredLoad) * vl_idle); |
| if(vl_idleTimeNext<(vl_idleTimeOrig / 2.0) or (vl_idleTimeOrig * 2.0)<vl_idleTimeNext) { // reset |
| vl_idleTimeNext := vl_idleTimeOrig; |
| vl_limNext := vl_limOrig; |
| // action("K.I. -",log2str("vl_idleTimeNext: ",((vl_elapsed / pl_desiredLoad) * vl_idle), " RESET => ", vl_idleTimeNext, " - vl_limNext: ", vl_limNext )); |
| } else { |
| vl_limRequested := float2int((vl_idleTime / vl_idleTimeNext) * int2float(vl_lim)); |
| vl_limNext := float2int( cl_requestedRate * int2float(vl_limRequested) + ((1.0-cl_requestedRate) * int2float(vl_limOrig))); // Limit correction |
| } |
| vl_loadFull := vl_loadFull + vl_elapsed; |
| vl_idleFull := vl_idleFull + vl_idleTimeNext; |
| vl_loadPercent := (vl_loadFull/(vl_loadFull+vl_idleFull)); |
| // action("K.I. - ",log2str("[", vl_j, "] - (vl_elapsed: ", vl_elapsed, "/ pl_desiredLoad: ", pl_desiredLoad, ") * vl_idle: ", vl_idle, " - vl_idleTimeNext: ", vl_idleTimeNext, " | vl_lim: ", vl_lim, " => vl_idleTime: ", vl_idleTime, " - vl_limNext: ", vl_limNext, " - vl_limRequested: ", vl_limRequested , " - vl_loadPercent: ", vl_loadPercent )); |
| vl_j := vl_j+1; |
| vl_idleTime := vl_idleTimeNext; |
| vl_lim := vl_limNext; |
| T.start(vl_idleTime); |
| repeat; |
| } |
| } |
| |
| } |
| |
| |
| } // group HostAdminServer |
| |
| |
| group Help { |
| |
| type component HostAdmin_HelpTest_CT extends EPTF_DataSource_CT { |
| var boolean v_HostAdmin_ready := false; |
| var boolean v_HostAdminServer_ready := false; |
| } |
| |
| function f_EPTF_HostAdmin_Test_checkHostAdminReady( |
| in charstring pl_source, |
| in charstring pl_ptcName |
| ) runs on HostAdmin_HelpTest_CT { |
| if (pl_source==c_HostAdmin_DataSource_sourceId) { |
| v_HostAdmin_ready := true; |
| } |
| if (pl_source==c_HostAdminServer_DataSource_sourceId) { |
| v_HostAdminServer_ready := true; |
| } |
| } |
| |
| function f_EPTF_HostAdmin_Test_helpCheck(in charstring pl_source := "", in charstring pl_element := "", in charstring pl_expectedPattern := "") runs on HostAdmin_HelpTest_CT { |
| var charstring vl_helpTEXT; |
| var octetstring vl_helpJSON; |
| vl_helpTEXT := f_EPTF_DataSource_getHelpTEXT(pl_source, pl_element); |
| action("Help for "&pl_source&": ", vl_helpTEXT); |
| if (pl_expectedPattern!="") { |
| // check if the TEXT help contains the pattern: |
| if(not match(vl_helpTEXT,pattern pl_expectedPattern)) { |
| setverdict(fail,"The TEXT help does not match the expected pattern: ", match(vl_helpTEXT,pattern pl_expectedPattern)); |
| f_EPTF_Base_stop(none); |
| } |
| } |
| |
| vl_helpJSON := f_EPTF_DataSource_getHelpJSON(pl_source,pl_element); |
| action("HelpJSON for "&pl_source&": ", vl_helpJSON); |
| } |
| |
| testcase tc_EPTF_HostAdmin_Test_help() runs on HostAdmin_HelpTest_CT { |
| f_EPTF_DataSource_init_CT("MTC"); |
| v_HostAdmin_ready := false; |
| v_HostAdminServer_ready := false; |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_HostAdmin_Test_checkHostAdminReady)); |
| |
| var EPTF_HostAdminServer_CT vl_hostAdminServer := EPTF_HostAdminServer_CT.create; |
| vl_hostAdminServer.start(f_HostAdminServer_MultiHostTest_hostAdminServerBehaviour("hostAdminServer", self)); |
| |
| if(sizeof(tsp_uiDemoHostList) == 0) { |
| var EPTF_HostAdmin_CT vl_adm := EPTF_HostAdmin_CT.create(-, tsp_demoHost); |
| vl_adm.start(f_EPTF_HostAdmin_test_behavior(c_hostAdmin_name, tsp_demoHost, mtc)); |
| } else { |
| for(var integer i:=0; i<sizeof(tsp_uiDemoHostList); i:=i+1) { |
| var EPTF_HostAdmin_CT vl_adm := EPTF_HostAdmin_CT.create(-, tsp_uiDemoHostList[i]); |
| vl_adm.start( |
| f_EPTF_HostAdmin_test_behavior(c_hostAdmin_name&"."&int2str(i), |
| tsp_uiDemoHostList[i], mtc)); |
| timer T:=0.1; |
| T.start;T.timeout; |
| } |
| } |
| |
| timer T_guard, T_alt; |
| T_guard.start( 100.0 ); |
| T_alt.start( 0.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| f_EPTF_Base_stopAll(); |
| } |
| [v_HostAdmin_ready and v_HostAdminServer_ready] T_alt.timeout{} |
| }; |
| |
| // HostAdmin |
| f_EPTF_HostAdmin_Test_helpCheck(pl_source := c_HostAdmin_DataSource_sourceId,pl_expectedPattern := "*Source: \""&c_HostAdmin_DataSource_sourceId&"\"\n\n*DataElement: \"help\"*") |
| |
| |
| // HostAdminServer: |
| f_EPTF_HostAdmin_Test_helpCheck(pl_source := c_HostAdminServer_DataSource_sourceId,pl_expectedPattern := "*Source: \""&c_HostAdminServer_DataSource_sourceId&"\"\n\n*DataElement: \"help\"*") |
| |
| setverdict(pass); |
| f_EPTF_Base_stop(none); |
| |
| |
| } |
| } //group Help |
| |
| |
| group OverloadDetection { |
| |
| type component HostAdmin_overloadDetection_test_Manual_CT extends SYSTEM_CT, EPTF_HostAdminServer_CT { |
| } |
| |
| function f_EPTF_HostAdmin_overloadDetection_test_dataSourceHandler( |
| out charstring pl_dataVarName, |
| in charstring pl_source, |
| in charstring pl_ptcName, |
| in charstring pl_element, |
| in EPTF_DataSource_Params pl_params |
| ) runs on HostAdmin_overloadDetection_test_Manual_CT return integer { |
| |
| pl_dataVarName := pl_element; |
| return 0; |
| } |
| |
| function f_EPTF_HostAdmin_overloadDetection_test_exitButtonPostProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on HostAdmin_overloadDetection_test_Manual_CT { |
| f_EPTF_Base_stopAll(none); |
| }; |
| |
| /////////////////////////////////////////////////////////// |
| // Testcase: tc_EPTF_HostAdmin_overloadDetection_test_Manual |
| // |
| // Purpose: |
| // To test graphically whether overload detection is working in Scheduler |
| // |
| // The GUI will display the current load measured by hostadmin |
| // as well as the load measured by Scheduler. The load |
| // can be controled from GUI. The overload LED should turn red |
| // in case the load is higher than a threshold |
| // |
| /////////////////////////////////////////////////////////// |
| testcase tc_EPTF_HostAdmin_overloadDetection_test_Manual() |
| runs on HostAdmin_overloadDetection_test_Manual_CT |
| { |
| f_EPTF_DataSource_init_CT("MTC"); |
| f_EPTF_HostAdminServer_init_CT("MTC",self); |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_HostAdmin_Test_DataSourceClientReady )); |
| f_EPTF_UIHandler_init_CT("MTC", true); |
| f_EPTF_UIHandler_clearGUI(); |
| f_EPTF_UIHandler_addWindow(); |
| |
| var integer vl_numberOfPTCs := tsp_customGUI_test_Manual_numberOfPTCs; |
| |
| for(var integer i:=0; i<vl_numberOfPTCs; i:=i+1) { |
| var EPTF_Scheduler_OverloadTest_CT vl_dumyComp := EPTF_Scheduler_OverloadTest_CT.create; |
| // var EPTF_Base_CT vl_dumyComp := EPTF_Base_CT.create(-,"esekits1066"); |
| vl_dumyComp.start(f_EPTF_Scheduler_Test_overloadDetection_behaviour("LoadGen"&int2str(i),0.0+0.2*int2float(i)/int2float(vl_numberOfPTCs))); |
| } |
| |
| // create a dataSource variable: |
| var integer vl_idx; |
| f_EPTF_Var_newInt("Exit",0,vl_idx); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, |
| { |
| funcRef := refers(f_EPTF_HostAdmin_overloadDetection_test_exitButtonPostProc), |
| argList := {} |
| } |
| ); |
| f_EPTF_DataSourceClient_registerData("HostAdminTest",f_EPTF_Base_selfName(),refers(f_EPTF_HostAdmin_overloadDetection_test_dataSourceHandler),self); |
| |
| f_EPTF_Var_newFloat("LoadInScheduler",0.0,vl_idx) |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| f_EPTF_DataSourceClient_registerData("LoadGen",f_EPTF_Base_selfName(),refers(f_EPTF_HostAdmin_overloadDetection_test_dataSourceHandler),mtc); |
| f_EPTF_DataSourceClient_registerData("LoadGen","HostAdmin-esekilxxen1841",refers(f_EPTF_HostAdmin_overloadDetection_test_dataSourceHandler),mtc); |
| |
| f_EPTF_Var_newFloat("targetLoad",0.0,vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_Var_newStatusLED("overloadLED",{led_green, "ok"},vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_Var_newFloat("overloadThreshold",0.0,vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| timer T_guard, T_alt; |
| T_guard.start( 100.0 ); |
| T_alt.start( 2.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| f_EPTF_Base_stopAll(); |
| } |
| [v_startBecauseDSIsReady > 0] T_alt.timeout{} |
| }; |
| |
| f_EPTF_UIHandler_createGUIFromFile("gui_genapp_hostadmin_tabpanel_withOverloadDetection.xml", tsp_EPTF_GUI_Main_Window_WidgetId); |
| |
| timer T_wait; |
| T_wait.start( 1500.0 ); |
| T_wait.timeout; |
| |
| f_EPTF_Base_wait4Shutdown(); |
| f_EPTF_Base_cleanup_CT(); |
| setverdict(pass); |
| } |
| |
| } // group OverloadDetection |
| |
| control { |
| |
| execute(tc_HostAdmin_LocalMeasure()); |
| execute(tc_EPTF_HostAdmin_Test_behavior()); |
| execute(tc_EPTF_HostAdmin_Base_Test_InitMeasInterface()); |
| execute(tc_EPTF_HostAdmin_Base_Test_CleanupMeasInterface()); |
| execute(tc_EPTF_HostAdmin_Base_Test_update()); |
| execute(tc_EPTF_HostAdmin_dataSource_test()); |
| execute(tc_HostAdmin_DS_Neg_WrongIteratorProcesses()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementHostCPULoad()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementProcName1()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementProcName2()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementProcCPULoad1()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementProcCPULoad2()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementProcMEMUsage1()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementProcMEMUsage2()); |
| |
| execute(tc_HostAdmin_DS_Neg_WrongIteratorCPUs()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementCPULoad1()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementCPULoad2()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementHostNumCPUs()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementHostPhysicalMemory()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementHostFreeMemory()); |
| |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementHostName()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementIPv4Addr()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementIPv6Addr()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementMinCPULoad()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementMaxCPULoad()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementAvgCPULoad()); |
| execute(tc_HostAdmin_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad()); |
| |
| execute(tc_HostAdminServer_DataTestTroughVariables()); |
| execute(tc_HostAdminServer_DataTestTroughVariables_WithGUI()); |
| |
| execute(tc_HostAdminServer_DataSourceTest()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorProcessSortOptionList()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorHosts()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorProcessNames()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorProcessesOnHost4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementProcessSortOption()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementNofHosts()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMem4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPhysicalMemHRF4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementFreeMem4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementFreeMemHRF4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorCpus1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorCpus2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorCpus3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongIteratorCpus4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuLoad4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad5()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPerCpuLoad6()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementSelfName1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementSelfName2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementSelfName3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementSelfName4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementSelfName5()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementSelfName6()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementSelfName7()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementHostName1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementHostName2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementHostName3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementHostName4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementHostName5()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPID1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPID2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPID3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPID4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementPID5()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsage5()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementMemUsageHRF5()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementIPv4Addr4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementIPv6Addr4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuMin4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuMax4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementCpuAvg4()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad1()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad2()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad3()); |
| execute(tc_HostAdminServer_DS_Neg_WrongDataElementResetMinMaxAvgCPULoad4()); |
| |
| execute(tc_EPTF_HostAdmin_Test_help()); |
| |
| } |
| } // module |
| |
