int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
struct tm time;
struct oh_handler_state l_handle;
memset(&time, 0, sizeof(struct tm));
memset(&l_handle, 0, sizeof(struct oh_handler_state));
/**************************
* Test : Invalid handle
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_sp_time(NULL, &time);
checkstatus(err, expected_err, testfail);
/**************************
* Test : Invalid pointer to time struct
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_sp_time(&l_handle, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Cleanup after all tests
***************************/
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id = 0;
SaHpiEventLogInfoT info;
struct oh_handler_state l_handle;
memset(&l_handle, 0, sizeof(struct oh_handler_state));
/**************************
* Test: Invalid handle
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_sel_info(NULL, id, &info);
checkstatus(err, expected_err, testfail);
/**************************
* Test: Invalid info space
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_get_sel_info(&l_handle, id, NULL);
checkstatus(err, expected_err, testfail);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiSessionIdT sessionid;
struct tm time;
memset(&time, 0, sizeof(struct tm));
struct snmp_bc_hnd custom_handle;
/**************************
* Test : Invalid handle
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_set_sp_time(NULL, &time);
checkstatus(err, expected_err, testfail);
/**************************
* Test : Invalid pointer to struct
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_set_sp_time(&custom_handle, 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;
SaHpiResourceIdT id =0;
SaHpiSensorNumT sid = 0;
SaHpiEventStateT state;
SaHpiSensorReadingT reading;
/**************************
* Test : NULL handle
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_sensor_reading(NULL, id, sid, &reading, &state);
checkstatus(err, expected_err, testfail);
return testfail;
}
int main()
{
int alldone = 0;
welcome();
do
{
if (checkdata() == 1)
{ resetstatus(); }
do
{
if (checkstatus() == 1)
{
if (restart())
{ break; }
}
displaystatus();
alldone = continueclipping();
}
while (alldone == 0);
resetstatus();
goodbye();
}
while (close() == 0);
return 0;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id =0;
SaHpiSensorNumT sid = 0;
SaHpiEventStateT state;
SaHpiSensorReadingT reading;
struct oh_handler_state dd_hnd = {
.rptcache = (RPTable *)NULL,
.eventq = NULL,
.config = NULL,
.data = (void *)NULL
};
/**************************
* Test NULL cache
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_sensor_reading(&dd_hnd, id, sid, &reading, &state);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
return testfail;
}
void AMSTRDHTrack::_writeEl(){
integer flag = (IOPA.WriteAll%10==1)
|| (checkstatus(AMSDBc::USED));
if(Out(flag) ){
#ifdef __WRITEROOT__
AMSJob::gethead()->getntuple()->Get_evroot02()->AddAMSObject(this);
#endif
}
}
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;
}
void setascii()
{
int j;
memset(cmdbuf,0,SIZE);
j=sprintf(cmdbuf,"%s\r\n",ascistr);
sendbuf(sockfd,cmdbuf,j);
readbuf(NULL,sockfd,srvbuf,SIZE);
checkstatus(srvbuf);
}
int setpasv()
{
int j,port1;
memset(cmdbuf,0,SIZE);
j=sprintf(cmdbuf,"%s\r\n",pasvstr);
sendbuf(sockfd,cmdbuf,j);
readbuf("Set PASV",sockfd,srvbuf,SIZE);
checkstatus(srvbuf);
port1=dealpasv(srvbuf); //get the pasv port
return port1;
}
void loginftp(char *user,char *pass)
{
int j;
show=1;
readbuf("Get banner",sockfd,srvbuf,SIZE);
show=0;
memset(cmdbuf,0,SIZE);
//USER
j=sprintf(cmdbuf,"%s %s\r\n",usrstr,user);
sendbuf(sockfd,cmdbuf,j);
readbuf(NULL,sockfd,srvbuf,SIZE);
checkstatus(srvbuf);
//PASS
memset(cmdbuf,0,SIZE);
j=sprintf(cmdbuf,"%s %s\r\n",passtr,pass);
sendbuf(sockfd,cmdbuf,j);
readbuf(NULL,sockfd,srvbuf,SIZE);
checkstatus(srvbuf);
printf("[+] User %s logged in\n",user);
}
void retrbuf(char *filename,char *buffer,int length,int port1)
{
int j;
printf("[+] RETR file %s\n",filename);
memset(cmdbuf,0,SIZE);
j=sprintf(cmdbuf,"%s %s\r\n",retrstr,filename);
sendbuf(sockfd,cmdbuf,j);
retrfile(buffer,length,port1);
readbuf(NULL,sockfd,srvbuf,SIZE);
checkstatus(srvbuf);
}
void storbuf(char *filename,char *buf,int size,int port)
{
int j;
printf("[+] STOR file %s\n",filename);
memset(cmdbuf,0,SIZE);
j=sprintf(cmdbuf,"%s %s\r\n",storstr,filename);
sendbuf(sockfd,cmdbuf,j);
storfile(buf,size,port);
//check if the content is send overd
readbuf(NULL,sockfd,srvbuf,SIZE);
checkstatus(srvbuf);
}
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;
}
void loginftp(SOCKET sockfd, char *user, char *pass)
{
int j;
show=1;
readbuf("Get FTP Server banner",sockfd, recvbuf, SIZE);
//show=0;
//send USER username
memset(sendbuf,0,BUFFSIZE);
j=sprintf(sendbuf,"%s %s\r\n", "USER", user);
writebuf("Send USER", sockfd,sendbuf,j);
readbuf(NULL,sockfd, recvbuf, BUFFSIZE);
checkstatus(recvbuf);
//send PASS password
memset(sendbuf,0,BUFFSIZE);
j=sprintf(sendbuf,"%s %s\r\n","PASS", pass);
writebuf("Send PASS", sockfd, sendbuf, j);
readbuf(NULL,sockfd,recvbuf, BUFFSIZE);
checkstatus(recvbuf);
printf("[+] User %s logged in.\r\n", user);
}
int checkpremise(struct Premise *p)
/*
**----------------------------------------------------------
** Checks if a particular premise is true
**----------------------------------------------------------
*/
{
if (p->variable == r_TIME || p->variable == r_CLOCKTIME)
return(checktime(p));
else if (p->status > IS_NUMBER)
return(checkstatus(p));
else
return(checkvalue(p));
}
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;
}
void setport(char *l,int pt1)
{
int a,i,b,c,j;
char buf[30];
memset(buf,0,30);
i=sprintf(buf,"%s",l);
for(a=0;a<i;a++)
if(buf[a]=='.') buf[a]=',';
memset(cmdbuf,0,SIZE);
b=(pt1 >> 8 ) & 0xff;
c=pt1 & 0xff;
j=sprintf(cmdbuf,"%s %s,%d,%d\r\n",portstr,buf,b,c);
printf("[+] %s",cmdbuf);
sendbuf(sockfd,cmdbuf,j);
readbuf(NULL,sockfd,srvbuf,SIZE);
checkstatus(srvbuf);
}
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 close()
{
char close;
do
{
if (checkstatus() == 1)
{ resetstatus(); }
printf("close now?\n");
printf("[y/n]: ");
scanf(" %c", &close);
}
while ((close != 'y') && (close != 'n'));
if (close == 'y')
{
printf("\nbye-bye!\n");
return 1;
}
return 0;
}
void
cmp_attach(struct device *parent, struct device *self, void *aux)
{
struct mainbus_attach_args *ma = aux;
struct mainbus_attach_args nma;
char buf[32];
int node;
printf("\n");
for (node = OF_child(ma->ma_node); node; node = OF_peer(node)) {
if (!checkstatus(node))
continue;
OF_getprop(node, "name", buf, sizeof(buf));
if (strcmp(buf, "cpu") == 0)
OF_getprop(node, "compatible", buf, sizeof(buf));
bzero(&nma, sizeof(nma));
nma.ma_node = node;
nma.ma_name = buf;
config_found(self, &nma, cmp_print);
}
}
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;
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;
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;
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;
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;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiEventLogEntryIdT current = 0;
SaHpiEventLogEntryIdT previd;
SaHpiEventLogEntryIdT nextid;
SaHpiEventLogEntryT entry;
SaHpiRdrT rdr;
SaHpiRptEntryT rptentry;
struct oh_handler_state l_handle;
memset(&l_handle, 0, sizeof(struct oh_handler_state));
/**************************
* Test: NULL handle, rdr, rpt
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_sel_entry(NULL, id, current, &previd, &nextid, &entry, NULL, NULL);
checkstatus(err, expected_err,testfail);
/**************************
* Test: NULL previd
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_get_sel_entry(&l_handle, id, current,
NULL, &nextid, &entry, NULL, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test: NULL nextid
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_get_sel_entry(&l_handle, id, current,
&previd, NULL, &entry, NULL, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test: NULL nextid
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_get_sel_entry(&l_handle, id, current,
&previd, &nextid, NULL, NULL, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test: NULL handle
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_get_sel_entry(NULL, id, current,
&previd, &nextid, &entry, &rdr, &rptentry);
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;
}
