int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
SaHpiEventStateT state;
SaHpiSensorReadingT reading;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
struct oh_handler l_handler;
struct oh_handler *h= &l_handler;
SaHpiRptEntryT rptentry;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
return -1;
}
err = tfind_resource(&sessionid, (SaHpiCapabilitiesT) SAHPI_CAPABILITY_SENSOR, h, &rptentry);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
err = tcleanup(&sessionid);
return -1;
}
/**************************
* Test 3: Invalid ResourceId
**************************/
id = 5000;
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = snmp_bc_get_sensor_reading((void *)h->hnd, id, sid, &reading, &state);
checkstatus(&err, &expected_err, &testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int
main(int argc, const char *argv[])
{
args(argc, argv);
input();
tsetup();
tmain();
tend();
yank();
return 0;
}
RC InputThread::run() {
tsetup();
printf("Running InputThread %ld\n",_thd_id);
if(ISCLIENT) {
client_recv_loop();
} else {
server_recv_loop();
}
return FINISH;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
SaHpiEventStateT state;
SaHpiSensorReadingT reading;
/* *************************************
* Find a resource with NO Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_SENSOR, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_FALSE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test 20: Invalid ResourceId
***************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = snmp_bc_get_sensor_eventstate(sessionid, 5000, sid, &reading, &state);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
RC OutputThread::run() {
tsetup();
printf("Running OutputThread %ld\n",_thd_id);
while (!simulation->is_done()) {
heartbeat();
messager->run();
}
printf("FINISH %ld:%ld\n",_node_id,_thd_id);
fflush(stdout);
return FINISH;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
SaHpiSensorThresholdsT thres;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_FALSE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test : Invalid capability
**************************/
expected_err = SA_ERR_HPI_CAPABILITY;
err = saHpiSensorThresholdsSet(sessionid, id, sid, &thres);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiPowerStateT state;
/* *************************************
* Find a resource
* * ************************************* */
struct oh_handler l_handler;
struct oh_handler *h= &l_handler;
SaHpiRptEntryT rptentry;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! can not setup test environment\n");
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_POWER, h, &rptentry);
if (err != SA_OK) {
printf("Error! can not setup test environment\n");
err = tcleanup(&sessionid);
return -1;
}
id = rptentry.ResourceId;
/**************************
* Test :
**************************/
expected_err = SA_OK;
err = snmp_bc_get_power_state((void *)h->hnd, id, &state);
checkstatus(&err, &expected_err, &testfail);
/**************************&*
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
/* *************************************
* Find a resource with EventLog type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_EVENT_LOG, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Can not find a control resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test 001: snmp_bc_get_sel_info()
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_clear_sel(NULL, id);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiSessionIdT sessionid;
SaHpiEntityPathT ep_root;
/* *************************************
* Find a resource
* * ************************************* */
struct oh_handler l_handler;
struct oh_handler *h= &l_handler;
SaHpiRptEntryT rptentry;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! can not setup test environment\n");
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_POWER, h, &rptentry);
if (err != SA_OK) {
printf("Error! can not setup test environment\n");
err = tcleanup(&sessionid);
return -1;
}
struct oh_handler_state *handle = (struct oh_handler_state *)h->hnd;
char *root_tuple = (char *)g_hash_table_lookup(handle->config, "entity_root");
oh_encode_entitypath(root_tuple, &ep_root);
/**************************
* Test :
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_discover(NULL, &ep_root);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Test :
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_discover(handle, NULL);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Test :
**************************/
expected_err = SA_OK;
err = snmp_bc_discover_resources((void *)h->hnd);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
int testfail = 0;
SaErrorT err, expected_err;
SaHpiHsIndicatorStateT hs_ind_state = SAHPI_HS_INDICATOR_OFF;
SaHpiHsStateT hs_state = SAHPI_HS_STATE_INACTIVE;
SaHpiHsActionT act = 0;
SaHpiResourceIdT id = 0;
SaHpiRptEntryT rptentry;
SaHpiSessionIdT sessionid;
SaHpiTimeoutT timeout = SAHPI_TIMEOUT_IMMEDIATE;
/*****************************************
* Find a resource with hotswap capability
*****************************************/
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Cannot open session\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_FRU, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
dbg("Cannot find a hotswap resource\n");
dbg(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/******************************
* Test: Bad parameter checking
******************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = saHpiAutoInsertTimeoutGet(sessionid, NULL);
checkstatus(err, expected_err, testfail);
err = saHpiAutoInsertTimeoutSet(sessionid, -5);
checkstatus(err, expected_err, testfail);
err = saHpiAutoExtractTimeoutGet(sessionid, id, NULL);
checkstatus(err, expected_err, testfail);
err = saHpiAutoExtractTimeoutSet(sessionid, id, -5);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapStateGet(sessionid, id, NULL);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapActionRequest(sessionid, id, -1);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapIndicatorStateGet(sessionid, id, NULL);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapIndicatorStateSet(sessionid, id, -1);
checkstatus(err, expected_err, testfail);
/*******************************
* Test: Invalid session checking
*******************************/
expected_err = SA_ERR_HPI_INVALID_SESSION;
err = saHpiHotSwapPolicyCancel(-1, id);
checkstatus(err, expected_err, testfail);
err = saHpiResourceActiveSet(-1, id);
checkstatus(err, expected_err, testfail);
err = saHpiResourceInactiveSet(-1, id);
checkstatus(err, expected_err, testfail);
err = saHpiAutoInsertTimeoutGet(-1, &timeout);
checkstatus(err, expected_err, testfail);
err = saHpiAutoInsertTimeoutSet(-1, timeout);
checkstatus(err, expected_err, testfail);
err = saHpiAutoExtractTimeoutGet(-1, id, &timeout);
checkstatus(err, expected_err, testfail);
err = saHpiAutoExtractTimeoutSet(-1, id, timeout);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapStateGet(-1, id, &hs_state);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapActionRequest(-1, id, act);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapIndicatorStateGet(-1, id, &hs_ind_state);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapIndicatorStateSet(-1, id, hs_ind_state);
checkstatus(err, expected_err, testfail);
/****************************
* Test: Invalid RID checking
****************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = saHpiHotSwapPolicyCancel(sessionid, -1);
checkstatus(err, expected_err, testfail);
err = saHpiResourceActiveSet(sessionid, -1);
checkstatus(err, expected_err, testfail);
err = saHpiResourceInactiveSet(sessionid, -1);
checkstatus(err, expected_err, testfail);
err = saHpiAutoExtractTimeoutGet(sessionid, -1, &timeout);
checkstatus(err, expected_err, testfail);
err = saHpiAutoExtractTimeoutSet(sessionid, -1, timeout);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapStateGet(sessionid, -1, &hs_state);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapActionRequest(sessionid, -1, act);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapIndicatorStateGet(sessionid, -1, &hs_ind_state);
checkstatus(err, expected_err, testfail);
err = saHpiHotSwapIndicatorStateSet(sessionid, -1, hs_ind_state);
checkstatus(err, expected_err, testfail);
/*************************
* Cleanup after all tests
*************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT dd_sid = 0;
SaHpiEventStateT state;
SaHpiSensorReadingT reading;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
struct oh_handler l_handler;
struct oh_handler *h= &l_handler;
SaHpiRptEntryT rptentry;
SaHpiRdrT *rdrptr;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
return -1;
}
err = tfind_resource(&sessionid, (SaHpiCapabilitiesT) SAHPI_CAPABILITY_SENSOR, h, &rptentry);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
err = tcleanup(&sessionid);
return -1;
}
struct oh_handler_state *handle = (struct oh_handler_state *)h->hnd;
id = rptentry.ResourceId;
/**************************
* Test 10
**************************/
dd_sid = 0;
do {
dd_sid++;
rdrptr = oh_get_rdr_by_type(handle->rptcache, id, SAHPI_SENSOR_RDR, dd_sid);
if (rdrptr != NULL) {
if (rdrptr->RdrTypeUnion.SensorRec.DataFormat.IsSupported == SAHPI_FALSE) {
break;
} else
rdrptr = NULL;
}
} while ((rdrptr == NULL) && (dd_sid < 128));
if (rdrptr == NULL) testfail = -1;
/**************************
* Test 11
**************************/
expected_err = SA_OK;
err = snmp_bc_get_sensor_reading((void *)h->hnd, id, dd_sid, &reading, &state);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Test 12
**************************/
if (reading.IsSupported ) {
printf("\t Reading Is Supported for sensor %d!\n\n", dd_sid);
testfail = -1;
}
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiCtrlNumT cid = 1;
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundControl;
/* *************************************
* Find a resource with Control type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_CONTROL, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Can not find a control resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find a control RDR
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundControl = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if (rdr.RdrType == SAHPI_CTRL_RDR)
{
foundControl = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundControl) {
err("Did not find desired resource for test\n");
return(SA_OK);
} else {
cid = rdr.RdrTypeUnion.CtrlRec.Num;
}
/**************************
* Test 1: Normal get
*************************/
expected_err = SA_OK;
err = saHpiControlGet(sessionid, id, cid, &mode, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 2: Get with no mode
* expected_err = SA_OK;
*************************/
err = saHpiControlGet(sessionid, id, cid, NULL, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 3: Get with no state
* expected_err = SA_OK;
*************************/
err = saHpiControlGet(sessionid, id, cid, &mode, NULL);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundSensor;
SaHpiSensorNumT sid = 0;
SaHpiBoolT enable = SAHPI_FALSE;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find a sensor with desired property
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundSensor = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if ((rdr.RdrType == SAHPI_SENSOR_RDR) &&
(rdr.RdrTypeUnion.SensorRec.DataFormat.IsSupported == SAHPI_FALSE))
{
foundSensor = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundSensor) {
dbg("Did not find desired resource for test\n");
return(SA_OK);
} else {
sid = rdr.RdrTypeUnion.SensorRec.Num;
}
/**************************
* Test: enable event for nonsupported capability
**************************/
expected_err = SA_ERR_HPI_READ_ONLY;
err = saHpiSensorEventEnableSet(sessionid, id, sid, enable);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiSensorNumT dd_sid = 0;
SaHpiEventStateT state;
SaHpiSensorReadingT reading;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundSensor;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return -1;
}
id = rptentry.ResourceId;
/**************************
* Test: find a sensor with desired property
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundSensor = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if ((rdr.RdrType == SAHPI_SENSOR_RDR) &&
(rdr.RdrTypeUnion.SensorRec.DataFormat.IsSupported == SAHPI_TRUE))
{
foundSensor = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundSensor) {
err("Did not find desired resource for test\n");
return(SA_OK);
} else {
dd_sid = rdr.RdrTypeUnion.SensorRec.Num;
}
/**************************
* Test : Read sensor with NULL Reading area. State only
**************************/
expected_err = SA_OK;
err = saHpiSensorReadingGet(sessionid, id, dd_sid, NULL, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test:Read with NULL State area, Read Value only
**************************/
err = saHpiSensorReadingGet(sessionid, id, dd_sid, &reading, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test: Both Reading and State are NULL. ie checking for sensor existance
**************************/
err = saHpiSensorReadingGet(sessionid, id, dd_sid, NULL, NULL);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiIdrIdT idrId= 0;
SaHpiEntryIdT areaId = 0;
/* SaHpiIdrAreaTypeT areatype; */
SaHpiEntryIdT nextAreaId;
SaHpiIdrAreaHeaderT header;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundControl;
/* *************************************
* Find a resource with inventory capability
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_INVENTORY_DATA, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Can not find an Inventory resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find an Inventory RDR
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundControl = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if (rdr.RdrType == SAHPI_INVENTORY_RDR)
{
foundControl = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundControl) {
dbg("Did not find desired resource for test\n");
return(SA_OK);
} else {
idrId = rdr.RdrTypeUnion.InventoryRec.IdrId;
}
/**************************
* Test: Invalid IdrId
**************************/
expected_err = SA_ERR_HPI_NOT_PRESENT;
err = saHpiIdrAreaHeaderGet(sessionid , id, 5000,
SAHPI_IDR_AREATYPE_UNSPECIFIED,
areaId, &nextAreaId, &header);
checkstatus(err, expected_err, testfail);
/**************************
* Test: Invalid AreaType
**************************/
expected_err = SA_OK;
err = saHpiIdrAreaHeaderGet(sessionid , id, idrId,
SAHPI_IDR_AREATYPE_UNSPECIFIED,
areaId, &nextAreaId, &header);
checkstatus(err, expected_err, testfail);
/**************************
* Test: Normal code path
**************************/
expected_err = SA_OK;
err = saHpiIdrAreaHeaderGet(sessionid , id, idrId,
SAHPI_IDR_AREATYPE_UNSPECIFIED,
SAHPI_FIRST_ENTRY, &nextAreaId, &header);
checkstatus(err, expected_err, testfail);
/**************************&*
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
int testfail = 0;
SaErrorT err, expected_err;
SaHpiResetActionT act = 0;
SaHpiResourceIdT id = 0;
SaHpiRptEntryT rptentry;
SaHpiSessionIdT sessionid;
/***************************************
* Find a resource with Reset capability
***************************************/
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Cannot open session\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_RESET, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Cannot find a Reset capable resource\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
#if 0
printf("Found resource = %s\n", rptentry.ResourceTag.Data);
#endif
/***********************
* Test: Invalid session
***********************/
expected_err = SA_ERR_HPI_INVALID_SESSION;
err = saHpiResourceResetStateGet(-1, id, &act);
checkstatus(err, expected_err, testfail);
err = saHpiResourceResetStateSet(-1, id, act);
checkstatus(err, expected_err, testfail);
/************************
* Test: Invalid resource
************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = saHpiResourceResetStateGet(sessionid, -1, &act);
checkstatus(err, expected_err, testfail);
err = saHpiResourceResetStateSet(sessionid, -1, act);
checkstatus(err, expected_err, testfail);
/**************************
* Test: Invalid parameters
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = saHpiResourceResetStateGet(sessionid, id, NULL);
checkstatus(err, expected_err, testfail);
err = saHpiResourceResetStateSet(sessionid, id, -1);
checkstatus(err, expected_err, testfail);
/***********************
* Test: Invalid command
***********************/
expected_err = SA_ERR_HPI_INVALID_CMD;
err = saHpiResourceResetStateSet(sessionid, id, SAHPI_RESET_ASSERT);
checkstatus(err, expected_err, testfail);
err = saHpiResourceResetStateSet(sessionid, id, SAHPI_RESET_DEASSERT);
checkstatus(err, expected_err, testfail);
/*************************
* Test: Normal operations
*************************/
expected_err = SA_OK;
act = SAHPI_COLD_RESET;
err = saHpiResourceResetStateSet(sessionid, id, act);
checkstatus(err, expected_err, testfail);
err = saHpiResourceResetStateGet(sessionid, id, &act);
checkstatus(err, expected_err, testfail);
if (act != SAHPI_RESET_DEASSERT) {
printf(" Error! Testcase failed. Line=%d\n", __LINE__);
printf(" Current state = %s\n", oh_lookup_resetaction(act));
return -1;
}
act = SAHPI_WARM_RESET;
err = saHpiResourceResetStateSet(sessionid, id, act);
checkstatus(err, expected_err, testfail);
err = saHpiResourceResetStateGet(sessionid, id, &act);
checkstatus(err, expected_err, testfail);
if (act != SAHPI_RESET_DEASSERT) {
printf(" Error! Testcase failed. Line=%d\n", __LINE__);
printf(" Current state = %s\n", oh_lookup_resetaction(act));
return -1;
}
/*************************
* Cleanup after all tests
*************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
struct SensorInfo *sinfo;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
struct oh_handler l_handler;
struct oh_handler *h= &l_handler;
SaHpiRptEntryT rptentry;
SaHpiRdrT *rdrptr;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
return -1;
}
err = tfind_resource(&sessionid, (SaHpiCapabilitiesT) SAHPI_CAPABILITY_SENSOR, h, &rptentry);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
err = tcleanup(&sessionid);
return -1;
}
struct oh_handler_state *handle = (struct oh_handler_state *)h->hnd;
id = rptentry.ResourceId;
/**************************
*
**************************/
sid = 0;
do {
sid++;
rdrptr = oh_get_rdr_by_type(handle->rptcache, id, SAHPI_SENSOR_RDR, sid);
if (rdrptr != NULL) {
if (rdrptr->RdrTypeUnion.SensorRec.EnableCtrl == SAHPI_FALSE) {
break;
} else
rdrptr = NULL;
}
} while ((rdrptr == NULL) && (sid < 128));
if (rdrptr == NULL) testfail = -1;
/**************************
* Test
**************************/
rdrptr->RdrTypeUnion.SensorRec.EnableCtrl = SAHPI_TRUE;
SaHpiBoolT enable = SAHPI_TRUE;
expected_err = SA_OK;
err = snmp_bc_set_sensor_enable((void *)h->hnd, id, sid, enable);
checkstatus(&err, &expected_err, &testfail);
sinfo = (struct SensorInfo *)oh_get_rdr_data(handle->rptcache, id, rdrptr->RecordId);
if (sinfo->sensor_enabled != enable) {
printf("snmp_bc_set_sensor_enable() fails\n");
testfail = -1;
}
/**************************
* Test
**************************/
enable = SAHPI_FALSE;
expected_err = SA_OK;
err = snmp_bc_set_sensor_enable((void *)h->hnd, id, sid, enable);
checkstatus(&err, &expected_err, &testfail);
sinfo = (struct SensorInfo *)oh_get_rdr_data(handle->rptcache, id, rdrptr->RecordId);
if (sinfo->sensor_enabled != enable) {
printf("snmp_bc_set_sensor_enable() fails\n");
testfail = -1;
}
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
SaHpiSensorEventMaskActionT act = SAHPI_SENS_ADD_EVENTS_TO_MASKS;
SaHpiEventStateT assertMask = SAHPI_ES_UPPER_MINOR;
SaHpiEventStateT deassertMask = SAHPI_ES_UPPER_CRIT;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundSensor;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find a sensor with desired property
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundSensor = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if ((rdr.RdrType == SAHPI_SENSOR_RDR) &&
(rdr.RdrTypeUnion.SensorRec.EventCtrl != SAHPI_SEC_PER_EVENT))
{
foundSensor = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundSensor) {
dbg("Did not find desired resource for test\n");
return(SA_OK);
} else {
sid = rdr.RdrTypeUnion.SensorRec.Num;
}
/**************************
* Test: Sensor with !SAHPI_SEC_PER_EVENT
**************************/
expected_err = SA_ERR_HPI_READ_ONLY;
err = saHpiSensorEventMasksSet(sessionid, id, sid, act, assertMask, deassertMask);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
SaHpiEventStateT assertMask;
SaHpiEventStateT deassertMask;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: Invalid assert and deassert masks
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = saHpiSensorEventMasksGet(sessionid, id, sid, NULL, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test:Invalid deassert mask
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = saHpiSensorEventMasksGet(sessionid, id, sid, &assertMask, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test Invalid assert mask
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = saHpiSensorEventMasksGet(sessionid, id, sid, NULL, &deassertMask);
checkstatus(err, expected_err, testfail);
/**************************
* Test Invalid resource Id
**************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = saHpiSensorEventMasksGet(sessionid, 5000, sid, &assertMask, &deassertMask);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaHpiResourceIdT id;
SaHpiParmActionT act;
SaErrorT err;
SaErrorT expected_err;
SaHpiSessionIdT sessionid;
/* ************************
* Find a resource with Control type rdr
* ***********************/
SaHpiRptEntryT rptentry;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not setup session for test environment.\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_CONTROL, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Error! Can not find resource for test environment.\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return -1;
}
struct oh_handler_state handle;
memset(&handle, 0, sizeof(struct oh_handler_state));
/**************************
* Test 1: Invalid Control Action
**************************/
id = rptentry.ResourceId;
expected_err = SA_ERR_HPI_INVALID_PARAMS;
act = 0xFF;
err = snmp_bc_control_parm(&handle, id, act);
checkstatus(err, expected_err, testfail);
/**************************
* Test 2: Invalid ResourceId
**************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
act = SAHPI_RESTORE_PARM;
err = snmp_bc_control_parm(&handle, 5000, act);
checkstatus(err, expected_err, testfail);
#if 0
/**************************
* Test 3: Resource configuration saving not supported
*************************/
rptentry.ResourceCapabilities |= SAHPI_CAPABILITY_CONFIGURATION;
oh_add_resource(handle->rptcache, &rptentry, NULL, 0);
expected_err = SA_ERR_HPI_INTERNAL_ERROR;
err = snmp_bc_control_parm(&handle, id, act);
checkstatus(err, expected_err, testfail);
#endif
/**************************
* Test 4: Normal Path
**************************/
expected_err = SA_ERR_HPI_CAPABILITY;
err = saHpiParmControl(sessionid, id, act);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiRdrT rdr;
SaHpiCtrlNumT cid = 1;
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
/* *************************************
* Find a resource with Control type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_CONTROL, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Can not find a control resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find a control RDR
**************************/
SaHpiEntryIdT entryid = SAHPI_FIRST_ENTRY;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundControl = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if (rdr.RdrType == SAHPI_CTRL_RDR)
{
foundControl = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundControl) {
dbg("Did not find desired resource for test\n");
return(SA_OK);
} else {
cid = rdr.RdrTypeUnion.CtrlRec.Num;
}
/**************************
* Test 1: Invalid Handle
*************************/
struct oh_handler_state l_handle;
memset(&l_handle, 0, sizeof(struct oh_handler_state));
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_control_state(NULL, id, cid, &mode, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 2: Resource ID with no RPT
*************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = saHpiControlGet(sessionid, 5000, cid, &mode, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 3: Control ID with no RDR
*************************/
expected_err = SA_ERR_HPI_NOT_PRESENT;
err = saHpiControlGet(sessionid, id, 5000, &mode, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 4: NULL mode and state
*************************/
expected_err = SA_OK;
err = saHpiControlGet(sessionid, id, cid, NULL, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test: resource without SAHPI_CAPABILITY_CONTROL
*************************/
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_CONTROL, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_FALSE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
expected_err = SA_ERR_HPI_CAPABILITY;
err = saHpiControlGet(sessionid, rptentry.ResourceId, cid, &mode, &state);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiDomainIdT did;
struct oh_domain *d;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
SaHpiSensorThresholdsT thres;
/* *************************************
* Find a resource with Sensor type rdr
* * ************************************* */
struct oh_handler l_handler;
struct oh_handler *h= &l_handler;
SaHpiRptEntryT rptentry;
SaHpiRdrT *rdrptr;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
return -1;
}
err = tfind_resource(&sessionid, (SaHpiCapabilitiesT) SAHPI_CAPABILITY_SENSOR, h, &rptentry);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
err = tcleanup(&sessionid);
return -1;
}
id = rptentry.ResourceId;
struct oh_handler_state *handle = (struct oh_handler_state *)h->hnd;
/**************************
*
**************************/
sid = 0;
do {
sid++;
rdrptr = oh_get_rdr_by_type(handle->rptcache, id, SAHPI_SENSOR_RDR, sid);
if (rdrptr != NULL) {
if (rdrptr->RdrTypeUnion.SensorRec.Category == SAHPI_EC_THRESHOLD)
break;
else
rdrptr = NULL;
}
} while ((rdrptr == NULL) && (sid < 128));
if (rdrptr == NULL) testfail = -1;
/**************************
* Test
**************************/
OH_GET_DID(sessionid, did);
OH_GET_DOMAIN(did, d); /* Lock domain */
rptentry.ResourceCapabilities &= !SAHPI_CAPABILITY_SENSOR;
oh_add_resource(handle->rptcache, &rptentry, NULL, 0);
oh_release_domain(d); /* Unlock domain */
expected_err = SA_ERR_HPI_CAPABILITY;
err = snmp_bc_set_sensor_thresholds((void *)h->hnd, id, sid, &thres);
checkstatus(&err, &expected_err, &testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
SaHpiBoolT enable = SAHPI_FALSE;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: Invalid handle
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_set_sensor_enable(NULL, id, sid, enable);
checkstatus(err, expected_err, testfail);
/**************************
* Test:Invalid resoruce id
**************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = saHpiSensorEnableSet(sessionid, 5000, sid, enable);
checkstatus(err, expected_err, testfail);
/**************************
* Test: invalid sensor Id
**************************/
expected_err = SA_ERR_HPI_NOT_PRESENT;
err = saHpiSensorEnableSet(sessionid, id, 5000, enable);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiIdrIdT idrId = 0;
SaHpiEntryIdT areaId = 0;
SaHpiEntryIdT fieldId = 0;
SaHpiIdrFieldT field;
memset (&field, 0, sizeof(SaHpiIdrFieldT));
/* *************************************
* Find a resource with Sensor type rdr
* * ************************************* */
struct oh_handler l_handler;
struct oh_handler *h= &l_handler;
SaHpiRptEntryT rptentry;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! can not setup test environment\n");
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_INVENTORY_DATA, h, &rptentry);
if (err != SA_OK) {
printf("Error! can not setup test environment\n");
err = tcleanup(&sessionid);
return -1;
}
id = rptentry.ResourceId;
/**************************
* Test :
**************************/
expected_err = SA_ERR_HPI_READ_ONLY;
err = snmp_bc_add_idr_area((void *)h->hnd, id, idrId, SAHPI_IDR_AREATYPE_UNSPECIFIED, &areaId);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Test :
* expected_err = SA_ERR_HPI_READ_ONLY;
**************************/
err = snmp_bc_add_idr_field((void *)h->hnd, id, idrId, &field);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Test :
* expected_err = SA_ERR_HPI_READ_ONLY;
**************************/
err = snmp_bc_del_idr_area((void *)h->hnd, id, idrId, areaId);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Test :
* expected_err = SA_ERR_HPI_READ_ONLY;
**************************/
err = snmp_bc_del_idr_field((void *)h->hnd, id, idrId, areaId, fieldId);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Test :
* expected_err = SA_ERR_HPI_READ_ONLY;
**************************/
err = snmp_bc_set_idr_field((void *)h->hnd, id, idrId, &field);
checkstatus(&err, &expected_err, &testfail);
/**************************&*
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiDomainIdT did;
struct oh_domain *d;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
SaHpiSensorEventMaskActionT act = SAHPI_SENS_ADD_EVENTS_TO_MASKS;
SaHpiEventStateT assertMask = SAHPI_ES_UPPER_MINOR;
SaHpiEventStateT deassertMask = SAHPI_ES_UPPER_CRIT;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
struct oh_handler l_handler;
struct oh_handler *h= &l_handler;
SaHpiRptEntryT rptentry;
SaHpiRdrT *rdrptr;
struct oh_handler_state *handle;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_SENSOR, h, &rptentry);
if (err != SA_OK) {
printf("Error! bc_sensor, can not setup test environment\n");
err = tcleanup(&sessionid);
return -1;
}
handle = (struct oh_handler_state *)h->hnd;
id = rptentry.ResourceId;
/**************************
*
**************************/
sid = 0;
do {
sid++;
rdrptr = oh_get_rdr_by_type(handle->rptcache, id, SAHPI_SENSOR_RDR, sid);
if (rdrptr != NULL) {
if (rdrptr->RdrTypeUnion.SensorRec.EventCtrl != SAHPI_SEC_PER_EVENT) {
break;
} else
rdrptr = NULL;
}
} while ((rdrptr == NULL) && (sid < 128));
if (rdrptr == NULL) testfail = -1;
/**************************
* Alter sensor characteristic
**************************/
rdrptr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_PER_EVENT;
OH_GET_DID(sessionid, did);
OH_GET_DOMAIN(did, d); /* Lock domain */
rptentry.ResourceCapabilities &= ~SAHPI_CAPABILITY_EVT_DEASSERTS;
oh_add_resource(handle->rptcache, &rptentry, NULL, 0);
oh_release_domain(d); /* Unlock domain */
/**************************
* Test
**************************/
assertMask = (rdrptr->RdrTypeUnion.SensorRec.Events);
deassertMask = ~(rdrptr->RdrTypeUnion.SensorRec.Events);
expected_err = SA_ERR_HPI_INVALID_DATA;
err = snmp_bc_set_sensor_event_masks((void *)h->hnd, id, sid, act, assertMask, deassertMask);
checkstatus(&err, &expected_err, &testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiIdrIdT idrId = 0;
SaHpiIdrInfoT info;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundControl;
/* *************************************
* Find a resource with inventory capability
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_INVENTORY_DATA, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Can not find an Inventory resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find an Inventory RDR
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundControl = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if (rdr.RdrType == SAHPI_INVENTORY_RDR)
{
foundControl = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundControl) {
dbg("Did not find desired resource for test\n");
return(SA_OK);
} else {
idrId = rdr.RdrTypeUnion.InventoryRec.IdrId;
}
/**************************
* Test : Invalid handle
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_idr_info(NULL , id, idrId, &info);
checkstatus(err, expected_err, testfail);
/**************************
* Test : Invalid info pointer
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = saHpiIdrInfoGet(sessionid, id, idrId, NULL);
checkstatus(err, expected_err, testfail);
/**************************&*
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
RC ClientThread::run() {
tsetup();
printf("Running ClientThread %ld\n",_thd_id);
BaseQuery * m_query;
uint64_t iters = 0;
uint32_t num_txns_sent = 0;
int txns_sent[g_servers_per_client];
for (uint32_t i = 0; i < g_servers_per_client; ++i)
txns_sent[i] = 0;
run_starttime = get_sys_clock();
while(!simulation->is_done()) {
heartbeat();
#if SERVER_GENERATE_QUERIES
break;
#endif
//uint32_t next_node = iters++ % g_node_cnt;
progress_stats();
int32_t inf_cnt;
uint32_t next_node = (((iters++) * g_client_thread_cnt) + _thd_id )% g_servers_per_client;
uint32_t next_node_id = next_node + g_server_start_node;
// Just in case...
if (iters == UINT64_MAX)
iters = 0;
#if LOAD_METHOD == LOAD_MAX
if ((inf_cnt = client_man.inc_inflight(next_node)) < 0)
continue;
m_query = client_query_queue.get_next_query(next_node,_thd_id);
if(last_send_time > 0) {
INC_STATS(get_thd_id(),cl_send_intv,get_sys_clock() - last_send_time);
}
last_send_time = get_sys_clock();
#elif LOAD_METHOD == LOAD_RATE
if ((inf_cnt = client_man.inc_inflight(next_node)) < 0)
continue;
uint64_t gate_time;
while((gate_time = get_sys_clock()) - last_send_time < send_interval) { }
if(last_send_time > 0) {
INC_STATS(get_thd_id(),cl_send_intv,gate_time - last_send_time);
}
last_send_time = gate_time;
m_query = client_query_queue.get_next_query(next_node,_thd_id);
#else
assert(false);
#endif
assert(m_query);
DEBUG("Client: thread %lu sending query to node: %u, %d, %f\n",
_thd_id, next_node_id,inf_cnt,simulation->seconds_from_start(get_sys_clock()));
Message * msg = Message::create_message((BaseQuery*)m_query,CL_QRY);
((ClientQueryMessage*)msg)->client_startts = get_sys_clock();
msg_queue.enqueue(get_thd_id(),msg,next_node_id);
num_txns_sent++;
txns_sent[next_node]++;
INC_STATS(get_thd_id(),txn_sent_cnt,1);
}
for (uint64_t l = 0; l < g_servers_per_client; ++l)
printf("Txns sent to node %lu: %d\n", l+g_server_start_node, txns_sent[l]);
//SET_STATS(get_thd_id(), total_runtime, get_sys_clock() - simulation->run_starttime);
printf("FINISH %ld:%ld\n",_node_id,_thd_id);
fflush(stdout);
return FINISH;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiSensorNumT sid = 0;
SaHpiSensorThresholdsT thres;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundSensor;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find a sensor with desired property
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundSensor = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if ((rdr.RdrType == SAHPI_SENSOR_RDR) &&
(rdr.RdrTypeUnion.SensorRec.Category == SAHPI_EC_THRESHOLD) &&
(rdr.RdrTypeUnion.SensorRec.ThresholdDefn.WriteThold == 0))
{
foundSensor = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundSensor) {
dbg("Did not find desired resource for test\n");
return(SA_OK);
} else {
sid = rdr.RdrTypeUnion.SensorRec.Num;
}
/**************************
* Test: setting to a non-writeable sensor
**************************/
expected_err = SA_ERR_HPI_INVALID_CMD;
err = saHpiSensorThresholdsSet(sessionid, id, sid, &thres);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiResetActionT act = 0;
struct oh_handler_state l_handle;
memset(&l_handle, 0, sizeof(struct oh_handler_state));
/* *************************************
* Find a resource with Power capability
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_POWER, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Can not find a Power resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: Normal path
**************************/
expected_err = SA_OK;
err = saHpiResourceResetStateGet(sessionid, id, &act);
checkstatus(err, expected_err, testfail);
/**************************
* Test: Invalid handle
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_reset_state(NULL, id, &act);
checkstatus(err, expected_err, testfail);
/**************************
* Test : Invalid pointer
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_get_reset_state(&l_handle, id, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test :
**************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = saHpiResourceResetStateGet(sessionid, 5000, &act);
checkstatus(err, expected_err, testfail);
/**************************&*
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiIdrIdT idrId = 0;
SaHpiEntryIdT areaId = 0;
/* SaHpiIdrAreaTypeT areatype; */
SaHpiEntryIdT nextAreaId;
SaHpiIdrAreaHeaderT header;
/* *************************************
* Find a resource with Sensor type rdr
* * ************************************* */
struct oh_handler l_handler;
struct oh_handler *h= &l_handler;
SaHpiRptEntryT rptentry;
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! can not setup test environment\n");
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_INVENTORY_DATA, h, &rptentry);
if (err != SA_OK) {
printf("Error! can not setup test environment\n");
err = tcleanup(&sessionid);
return -1;
}
id = rptentry.ResourceId;
/**************************
* Test :
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_idr_area_header(NULL , id, idrId,
SAHPI_IDR_AREATYPE_UNSPECIFIED,
areaId, &nextAreaId, &header);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Test :
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_get_idr_area_header((void *)h->hnd, id, idrId,
SAHPI_IDR_AREATYPE_UNSPECIFIED,
areaId, NULL, &header);
checkstatus(&err, &expected_err, &testfail);
/**************************
* Test :
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_get_idr_area_header((void *)h->hnd, id, idrId,
SAHPI_IDR_AREATYPE_UNSPECIFIED,
areaId, &nextAreaId, NULL);
checkstatus(&err, &expected_err, &testfail);
/**************************&*
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
