/* Test MINC API's
*/
int
main(int argc, char **argv)
{
int stat;
struct testinfo info;
milog_init("mincapi"); /* Disable error messages completely. */
milog_set_verbosity(0);
ncopts &= ~(NC_FATAL | NC_VERBOSE);
test1(&info, dimtab1, 3);
test2(&info, dimtab1, 3);
test3(&info, dimtab1, 3);
test4(&info, dimtab1, 3);
test5(&info, dimtab1, 3);
/* test6(&info, dimtab1, 3); */
test7(&info, dimtab1, 3);
stat = miicv_free(rand());
if (stat >= 0) {
FUNC_ERROR("miicv_free");
}
if (miclose(info.fd) != MI_NOERROR) {
FUNC_ERROR("miclose");
}
if (miclose(info.fd) != MI_ERROR) {
FUNC_ERROR("miclose");
}
if (miclose(rand()) != MI_ERROR) {
FUNC_ERROR("miclose");
}
unlink(info.name); /* Delete the temporary file. */
free(info.name); /* Free the temporary filename */
icv_tests();
fprintf(stderr, "**** Tests completed with ");
if (errors == 0) {
fprintf(stderr, "no errors\n");
}
else {
fprintf(stderr, "%ld error%s\n", errors, (errors == 1) ? "" : "s");
}
return (errors);
}
int
test2(struct testinfo *ip, struct dimdef *dims, int ndims)
{
int i, j, k;
int stat;
long coords[3];
float flt;
stat = miattputdbl(ip->fd, ip->imgid, MIvalid_max, (XSIZE * 10000.0));
if (stat < 0) {
FUNC_ERROR("miattputdbl");
}
stat = miattputdbl(ip->fd, ip->imgid, MIvalid_min, -(XSIZE * 10000.0));
if (stat < 0) {
FUNC_ERROR("miattputdbl");
}
ncendef(ip->fd); /* End definition mode. */
coords[0] = 0;
flt = -(XSIZE * 100000.0);
stat = mivarput1(ip->fd, ip->minid, coords, NC_FLOAT, MI_SIGNED, &flt);
if (stat < 0) {
FUNC_ERROR("mivarput1");
}
flt = XSIZE * 100000.0;
stat = mivarput1(ip->fd, ip->maxid, coords, NC_FLOAT, MI_SIGNED, &flt);
if (stat < 0) {
FUNC_ERROR("mivarput1");
}
for (i = 0; i < dims[TST_X].length; i++) {
for (j = 0; j < dims[TST_Y].length; j++) {
for (k = 0; k < dims[TST_Z].length; k++) {
int tmp = (i * 10000) + (j * 100) + k;
coords[TST_X] = i;
coords[TST_Y] = j;
coords[TST_Z] = k;
stat = mivarput1(ip->fd, ip->imgid, coords, NC_INT, MI_SIGNED, &tmp);
if (stat < 0) {
fprintf(stderr, "At (%d,%d,%d), status %d: ", i,j,k,stat);
FUNC_ERROR("mivarput1");
}
}
}
}
return (0);
}
static int powerdns_read_recursor(list_item_t *item) /* {{{ */
{
char *buffer = NULL;
int status;
char *dummy;
char *keys_list;
char *key;
char *key_saveptr;
char *value;
char *value_saveptr;
if (item->command == NULL) {
status = powerdns_update_recursor_command(item);
if (status != 0) {
ERROR("powerdns plugin: powerdns_update_recursor_command failed.");
return -1;
}
DEBUG("powerdns plugin: powerdns_read_recursor: item->command = %s;",
item->command);
}
assert(item->command != NULL);
status = powerdns_get_data(item, &buffer);
if (status != 0) {
ERROR("powerdns plugin: powerdns_get_data failed.");
return -1;
}
keys_list = strdup(item->command);
if (keys_list == NULL) {
FUNC_ERROR("strdup");
sfree(buffer);
return -1;
}
key_saveptr = NULL;
value_saveptr = NULL;
/* Skip the `get' at the beginning */
strtok_r(keys_list, " \t", &key_saveptr);
dummy = buffer;
while ((value = strtok_r(dummy, " \t\n\r", &value_saveptr)) != NULL) {
dummy = NULL;
key = strtok_r(NULL, " \t", &key_saveptr);
if (key == NULL)
break;
submit(item->instance, key, value);
} /* while (strtok_r) */
sfree(buffer);
sfree(keys_list);
return 0;
} /* }}} int powerdns_read_recursor */
/* Test MINC API's
*/
int main(int argc, char **argv)
{
struct testinfo info;
if(argc>1)
info.attribute_size=atoi(argv[1]);
else
info.attribute_size=100000;
printf("Running test with attribute size=%d\n",info.attribute_size);
test1(&info, dimtab1, 3);
test2(&info, dimtab1, 3);
test3(&info, dimtab1, 3);
if (miclose(info.fd) != MI_NOERROR) {
FUNC_ERROR("miclose");
}
unlink(info.name); /* Delete the temporary file. */
free(info.name); /* Free the temporary filename */
return (errors);
}
int
test3(struct testinfo *ip, struct dimdef *dims, int ndims)
{
/* Try to read the data back. */
size_t total;
long coords[3];
long lengths[3];
void *buf_ptr;
int *int_ptr;
int i, j, k;
int stat;
total = 1;
for (i = 0; i < ndims; i++) {
total *= dims[i].length;
}
buf_ptr = malloc(total * sizeof (int));
if (buf_ptr == NULL) {
fprintf(stderr, "Oops, malloc failed\n");
return (-1);
}
coords[TST_X] = 0;
coords[TST_Y] = 0;
coords[TST_Z] = 0;
lengths[TST_X] = dims[TST_X].length;
lengths[TST_Y] = dims[TST_Y].length;
lengths[TST_Z] = dims[TST_Z].length;
stat = mivarget(ip->fd, ip->imgid, coords, lengths, NC_INT, MI_SIGNED,
buf_ptr);
if (stat < 0) {
FUNC_ERROR("mivarget");
}
int_ptr = (int *) buf_ptr;
for (i = 0; i < dims[TST_X].length; i++) {
for (j = 0; j < dims[TST_Y].length; j++) {
for (k = 0; k < dims[TST_Z].length; k++) {
int tmp = (i * 10000) + (j * 100) + k;
if (*int_ptr != tmp) {
fprintf(stderr, "1. Data error at (%d,%d,%d)\n", i,j,k);
errors++;
}
int_ptr++;
}
}
}
free(buf_ptr);
return (0);
}
static int powerdns_get_data_stream (list_item_t *item, /* {{{ */
char **ret_buffer,
size_t *ret_buffer_size)
{
int sd;
int status;
char temp[4096];
char *buffer = NULL;
size_t buffer_size = 0;
sd = socket (PF_UNIX, item->socktype, 0);
if (sd < 0)
{
FUNC_ERROR ("socket");
return (-1);
}
struct timeval timeout;
timeout.tv_sec=5;
timeout.tv_usec=0;
status = setsockopt (sd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof (timeout));
status = connect (sd, (struct sockaddr *) &item->sockaddr,
sizeof (item->sockaddr));
if (status != 0)
{
FUNC_ERROR ("connect");
close (sd);
return (-1);
}
/* strlen + 1, because we need to send the terminating NULL byte, too. */
status = send (sd, item->command, strlen (item->command) + 1,
/* flags = */ 0);
if (status < 0)
{
FUNC_ERROR ("send");
close (sd);
return (-1);
}
while (42)
{
char *buffer_new;
status = recv (sd, temp, sizeof (temp), /* flags = */ 0);
if (status < 0)
{
FUNC_ERROR ("recv");
break;
}
else if (status == 0)
break;
buffer_new = (char *) realloc (buffer, buffer_size + status + 1);
if (buffer_new == NULL)
{
FUNC_ERROR ("realloc");
status = -1;
break;
}
buffer = buffer_new;
memcpy (buffer + buffer_size, temp, status);
buffer_size += status;
buffer[buffer_size] = 0;
} /* while (42) */
close (sd);
sd = -1;
if (status < 0)
{
sfree (buffer);
}
else
{
assert (status == 0);
*ret_buffer = buffer;
*ret_buffer_size = buffer_size;
}
return (status);
} /* }}} int powerdns_get_data_stream */
static int powerdns_get_data_dgram (list_item_t *item, /* {{{ */
char **ret_buffer,
size_t *ret_buffer_size)
{
int sd;
int status;
char temp[4096];
char *buffer = NULL;
size_t buffer_size = 0;
struct sockaddr_un sa_unix;
struct timeval stv_timeout;
cdtime_t cdt_timeout;
sd = socket (PF_UNIX, item->socktype, 0);
if (sd < 0)
{
FUNC_ERROR ("socket");
return (-1);
}
memset (&sa_unix, 0, sizeof (sa_unix));
sa_unix.sun_family = AF_UNIX;
sstrncpy (sa_unix.sun_path,
(local_sockpath != NULL) ? local_sockpath : PDNS_LOCAL_SOCKPATH,
sizeof (sa_unix.sun_path));
status = unlink (sa_unix.sun_path);
if ((status != 0) && (errno != ENOENT))
{
FUNC_ERROR ("unlink");
close (sd);
return (-1);
}
do /* while (0) */
{
/* We need to bind to a specific path, because this is a datagram socket
* and otherwise the daemon cannot answer. */
status = bind (sd, (struct sockaddr *) &sa_unix, sizeof (sa_unix));
if (status != 0)
{
FUNC_ERROR ("bind");
break;
}
/* Make the socket writeable by the daemon.. */
status = chmod (sa_unix.sun_path, 0666);
if (status != 0)
{
FUNC_ERROR ("chmod");
break;
}
cdt_timeout = plugin_get_interval () * 3 / 4;
if (cdt_timeout < TIME_T_TO_CDTIME_T (2))
cdt_timeout = TIME_T_TO_CDTIME_T (2);
CDTIME_T_TO_TIMEVAL (cdt_timeout, &stv_timeout);
status = setsockopt (sd, SOL_SOCKET, SO_RCVTIMEO, &stv_timeout, sizeof (stv_timeout));
if (status != 0)
{
FUNC_ERROR ("setsockopt");
break;
}
status = connect (sd, (struct sockaddr *) &item->sockaddr,
sizeof (item->sockaddr));
if (status != 0)
{
FUNC_ERROR ("connect");
break;
}
status = send (sd, item->command, strlen (item->command), 0);
if (status < 0)
{
FUNC_ERROR ("send");
break;
}
status = recv (sd, temp, sizeof (temp), /* flags = */ 0);
if (status < 0)
{
FUNC_ERROR ("recv");
break;
}
buffer_size = status + 1;
status = 0;
} while (0);
close (sd);
unlink (sa_unix.sun_path);
if (status != 0)
return (-1);
assert (buffer_size > 0);
buffer = (char *) malloc (buffer_size);
if (buffer == NULL)
{
FUNC_ERROR ("malloc");
return (-1);
}
memcpy (buffer, temp, buffer_size - 1);
buffer[buffer_size - 1] = 0;
*ret_buffer = buffer;
*ret_buffer_size = buffer_size;
return (0);
} /* }}} int powerdns_get_data_dgram */
/* Test case 1 - file creation & definition.
*/
static int test1(struct testinfo *ip, struct dimdef *dims, int ndims)
{
int varid;
int stat;
int i;
/* Test case #1 - file creation
*/
ip->name = micreate_tempfile();
if (ip->name == NULL) {
FUNC_ERROR("micreate_tempfile\n");
}
ip->fd = micreate(ip->name, NC_CLOBBER);
if (ip->fd < 0) {
FUNC_ERROR("micreate");
}
/* Have to use ncdimdef() here since there is no MINC equivalent. Sigh.
*/
for (i = 0; i < ndims; i++) {
/* Define the dimension
*/
ip->dim[i] = ncdimdef(ip->fd, dims[i].name, dims[i].length);
if (ip->dim[i] < 0) {
FUNC_ERROR("ncdimdef");
}
/* Create the dimension variable.
*/
varid = micreate_std_variable(ip->fd, dims[i].name, NC_DOUBLE, 0,
&ip->dim[i]);
if (varid < 0) {
FUNC_ERROR("micreate_std_variable");
}
stat = miattputdbl(ip->fd, varid, MIstep, 0.8);
if (stat < 0) {
FUNC_ERROR("miattputdbl");
}
stat = miattputdbl(ip->fd, varid, MIstart, 22.0);
if (stat < 0) {
FUNC_ERROR("miattputdbl");
}
}
/* Create the image-max variable.
*/
ip->maxid = micreate_std_variable(ip->fd, MIimagemax, NC_FLOAT, 0, NULL);
if (ip->maxid < 0) {
FUNC_ERROR("micreate_std_variable");
}
/* Create the image-min variable.
*/
ip->minid = micreate_std_variable(ip->fd, MIimagemin, NC_FLOAT, 0, NULL);
if (ip->minid < 0) {
FUNC_ERROR("micreate_std_variable");
}
ip->imgid = micreate_std_variable(ip->fd, MIimage, NC_INT, ndims, ip->dim);
if (ip->imgid < 0) {
FUNC_ERROR("micreate_std_variable");
}
ip->test_group = ncvardef(ip->fd,(char*)"test",NC_INT,0,0);/* micreate_group_variable(ip->fd,(char*)"test");*/
if(ip->test_group<0)
{
FUNC_ERROR("micreate_group_variable");
}
ip->large_attribute=calloc(ip->attribute_size,sizeof(char));
memset(ip->large_attribute,'X',ip->attribute_size-1);
ip->test_attribute = ncattput(ip->fd, ip->test_group, "test", NC_CHAR, ip->attribute_size, ip->large_attribute);
return (0);
}
static int
test3(struct testinfo *ip, struct dimdef *dims, int ndims)
{
/* Try to read the data back. */
size_t total;
long coords[3];
long lengths[3];
void *buf_ptr;
int *int_ptr;
int i, j, k;
int stat;
int varid;
int att_length;
nc_type att_datatype;
char *att;
total = 1;
for (i = 0; i < ndims; i++) {
total *= dims[i].length;
}
buf_ptr = malloc(total * sizeof (int));
if (buf_ptr == NULL) {
fprintf(stderr, "Oops, malloc failed\n");
return (-1);
}
coords[TST_X] = 0;
coords[TST_Y] = 0;
coords[TST_Z] = 0;
lengths[TST_X] = dims[TST_X].length;
lengths[TST_Y] = dims[TST_Y].length;
lengths[TST_Z] = dims[TST_Z].length;
stat = mivarget(ip->fd, ip->imgid, coords, lengths, NC_INT, MI_SIGNED,
buf_ptr);
if (stat < 0) {
FUNC_ERROR("mivarget");
}
int_ptr = (int *) buf_ptr;
for (i = 0; i < dims[TST_X].length; i++) {
for (j = 0; j < dims[TST_Y].length; j++) {
for (k = 0; k < dims[TST_Z].length; k++) {
int tmp = (i * 10000) + (j * 100) + k;
if (*int_ptr != tmp) {
fprintf(stderr, "1. Data error at (%d,%d,%d)\n", i,j,k);
errors++;
}
int_ptr++;
}
}
}
free(buf_ptr);
varid = ncvarid(ip->fd, "test");
if(varid<0)
FUNC_ERROR("ncvarid");
if ((ncattinq(ip->fd, varid, "test", &att_datatype, &att_length) == MI_ERROR) ||
(att_datatype != NC_CHAR))
FUNC_ERROR("ncattinq");
if(att_length!=ip->attribute_size)
FUNC_ERROR("Wrong attribute length!");
att=malloc(att_length);
if(miattgetstr(ip->fd, varid, "test", att_length, att)==NULL)
FUNC_ERROR("miattgetstr");
if(memcmp(att,ip->large_attribute,att_length)!=0)
FUNC_ERROR("Attribute contents mismath!");
free(att);
return (0);
}
void icv_tests(void)
{
/* Some random ICV tests */
int icv;
int stat;
int i;
double min, max;
icv = miicv_create();
if (icv < 0) {
FUNC_ERROR("miicv_create");
}
for (i = NC_BYTE; i <= NC_DOUBLE; i++) {
stat = miicv_setint(icv, MI_ICV_TYPE, i);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setstr(icv, MI_ICV_SIGN, MI_UNSIGNED);
stat = miicv_inqdbl(icv, MI_ICV_VALID_MAX, &max);
if (stat < 0) {
FUNC_ERROR("miicv_inqdbl");
}
stat = miicv_inqdbl(icv, MI_ICV_VALID_MIN, &min);
if (stat < 0) {
FUNC_ERROR("miicv_inqdbl");
}
switch (i) {
case NC_BYTE:
if (min != 0 || max != UCHAR_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_SHORT:
if (min != 0 || max != USHRT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_INT:
if (min != 0 || max != UINT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_FLOAT:
if (min != -FLT_MAX || max != FLT_MAX) {
fprintf(stderr, "Type %d min %g max %g, header min %g max %g\n",
i, min, max, FLT_MIN, FLT_MAX);
errors++;
}
break;
case NC_DOUBLE:
if (min != -DBL_MAX || max != DBL_MAX) {
fprintf(stderr, "Type %d min %g max %g, header min %g max %g\n",
i, min, max, DBL_MIN, DBL_MAX);
errors++;
}
break;
}
stat = miicv_setstr(icv, MI_ICV_SIGN, MI_SIGNED);
if (stat < 0) {
FUNC_ERROR("miicv_setstr");
}
stat = miicv_inqdbl(icv, MI_ICV_VALID_MAX, &max);
if (stat < 0) {
FUNC_ERROR("miicv_inqdbl");
}
stat = miicv_inqdbl(icv, MI_ICV_VALID_MIN, &min);
if (stat < 0) {
FUNC_ERROR("miicv_inqdbl");
}
switch (i) {
case NC_BYTE:
if (min != SCHAR_MIN || max != SCHAR_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_SHORT:
if (min != SHRT_MIN || max != SHRT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_INT:
if (min != INT_MIN || max != INT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_FLOAT:
if (min != -FLT_MAX || max != FLT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_DOUBLE:
if (min != -DBL_MAX || max != DBL_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
}
}
#if 0
/* For some reason we're allowed to set MI_ICV_TYPE to an illegal value.
*/
stat = miicv_setint(icv, MI_ICV_TYPE, 1000);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
#endif
stat = miicv_setint(icv, MI_ICV_NUM_IMGDIMS, MI_MAX_IMGDIMS + 1);
if (stat >= 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_NUM_IMGDIMS, MI_MAX_IMGDIMS);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
miicv_free(icv);
}
int
test7(struct testinfo *ip, struct dimdef *dims, int ndims)
{
size_t total;
long coords[3];
long lengths[3];
void *buf_ptr;
int *int_ptr;
int i, j, k;
int stat;
int icv;
total = 1;
for (i = 0; i < ndims; i++) {
total *= dims[i].length;
}
buf_ptr = malloc(total * sizeof (float));
if (buf_ptr == NULL) {
fprintf(stderr, "Oops, malloc failed\n");
return (-1);
}
icv = miicv_create();
if (icv < 0) {
FUNC_ERROR("miicv_create");
}
/* Test range conversion. */
stat = miicv_setint(icv, MI_ICV_DO_DIM_CONV, 0);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_DO_RANGE, 1);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setstr(icv, MI_ICV_SIGN, MI_UNSIGNED);
if (stat < 0) {
FUNC_ERROR("miicv_setstr");
}
stat = miicv_setint(icv, MI_ICV_TYPE, NC_INT);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_VALID_MAX, 1000);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_VALID_MIN, -1000);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_attach(icv, ip->fd, ip->imgid);
if (stat < 0) {
FUNC_ERROR("miicv_attach");
}
coords[TST_X] = 0;
coords[TST_Y] = 0;
coords[TST_Z] = 0;
lengths[TST_X] = dims[TST_X].length;
lengths[TST_Y] = dims[TST_Y].length;
lengths[TST_Z] = dims[TST_Z].length;
stat = miicv_get(icv, coords, lengths, buf_ptr);
if (stat < 0) {
FUNC_ERROR("miicv_get");
}
int_ptr = (int *) buf_ptr;
for (i = 0; i < dims[TST_X].length; i++) {
for (j = 0; j < dims[TST_Y].length; j++) {
for (k = 0; k < dims[TST_Z].length; k++, int_ptr++) {
int tmp = (i * 10000) + (j * 100) + (k);
int rng = (XSIZE * 10000) / 1000;
/* Round tmp properly. */
tmp = (tmp + (rng / 2)) / rng;
if (*int_ptr != tmp) {
fprintf(stderr, "5. Data error at (%d,%d,%d) %d != %d\n",
i,j,k, *int_ptr, tmp);
errors++;
}
}
}
}
stat = miicv_detach(icv);
if (stat < 0) {
FUNC_ERROR("miicv_detach");
}
/* Free the ICV */
stat = miicv_free(icv);
if (stat < 0) {
FUNC_ERROR("miicv_free");
}
free(buf_ptr);
return (0);
}
int
test6(struct testinfo *ip, struct dimdef *dims, int ndims)
{
size_t total;
long coords[3];
long lengths[3];
void *buf_ptr;
int *int_ptr;
int i, j, k;
int stat;
int icv;
total = 1;
total *= dims[TST_X].length;
total *= dims[TST_Y].length - YBOOST;
total *= dims[TST_Z].length - ZBOOST;
buf_ptr = malloc(total * sizeof (int));
if (buf_ptr == NULL) {
fprintf(stderr, "Oops, malloc failed\n");
return (-1);
}
icv = miicv_create();
if (icv < 0) {
FUNC_ERROR("miicv_create");
}
/* Now try reading the image with reduced size.
*/
stat = miicv_setint(icv, MI_ICV_BDIM_SIZE, dims[TST_Y].length - YBOOST);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_ADIM_SIZE, dims[TST_Z].length - ZBOOST);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_DO_DIM_CONV, 1);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_attach(icv, ip->fd, ip->imgid);
if (stat < 0) {
FUNC_ERROR("miicv_attach");
}
coords[TST_X] = 0;
coords[TST_Y] = 0;
coords[TST_Z] = 0;
lengths[TST_X] = dims[TST_X].length;
lengths[TST_Y] = dims[TST_Y].length - YBOOST;
lengths[TST_Z] = dims[TST_Z].length - ZBOOST;
stat = miicv_get(icv, coords, lengths, buf_ptr);
if (stat < 0) {
FUNC_ERROR("miicv_get");
}
int_ptr = (int *) buf_ptr;
for (i = 0; i < dims[TST_X].length; i++) {
for (j = 0; j < dims[TST_Y].length - YBOOST; j++) {
for (k = 0; k < dims[TST_Z].length - ZBOOST; k++, int_ptr++) {
int tmp;
tmp = (i * 10000) + (j * 100) + (k);
if (*int_ptr != (int) tmp) {
fprintf(stderr, "4. Data error at (%d,%d,%d) %d != %d\n",
i,j,k, *int_ptr, tmp);
errors++;
}
}
}
}
stat = miicv_detach(icv);
if (stat < 0) {
FUNC_ERROR("miicv_detach");
}
stat = miicv_free(icv);
if (stat < 0) {
FUNC_ERROR("miicv_free");
}
free(buf_ptr);
return (0);
}
/* Test case 1 - file creation & definition.
*/
int
test1(struct testinfo *ip, struct dimdef *dims, int ndims)
{
int fd2;
int varid;
int stat;
int i;
/* Test case #1 - file creation
*/
ip->name = micreate_tempfile();
if (ip->name == NULL) {
FUNC_ERROR("micreate_tempfile\n");
}
ip->fd = micreate(ip->name, NC_CLOBBER);
if (ip->fd < 0) {
FUNC_ERROR("micreate");
}
/* Try to create another file of the same name - should fail.
*/
fd2 = micreate(ip->name, NC_NOCLOBBER);
if (fd2 >= 0) {
FUNC_ERROR("micreate");
}
/* Try to open the file for write - should fail.
*/
/* VF: it doesn't fail!
fd2 = miopen(ip->name, NC_WRITE);
if (fd2 >= 0) {
FUNC_ERROR("miopen");
} */
/* Have to use ncdimdef() here since there is no MINC equivalent. Sigh.
*/
for (i = 0; i < ndims; i++) {
/* Define the dimension
*/
ip->dim[i] = ncdimdef(ip->fd, dims[i].name, dims[i].length);
if (ip->dim[i] < 0) {
FUNC_ERROR("ncdimdef");
}
/* Create the dimension variable.
*/
varid = micreate_std_variable(ip->fd, dims[i].name, NC_DOUBLE, 0,
&ip->dim[i]);
if (varid < 0) {
FUNC_ERROR("micreate_std_variable");
}
stat = miattputdbl(ip->fd, varid, MIstep, 0.8);
if (stat < 0) {
FUNC_ERROR("miattputdbl");
}
stat = miattputdbl(ip->fd, varid, MIstart, 22.0);
if (stat < 0) {
FUNC_ERROR("miattputdbl");
}
}
/* Try to create a bogus variable. This should trigger an error.
*/
varid = micreate_std_variable(ip->fd, "xyzzy", NC_DOUBLE, 0, NULL);
if (varid >= 0) {
FUNC_ERROR("micreate_std_variable");
}
/* Create the image-max variable.
*/
ip->maxid = micreate_std_variable(ip->fd, MIimagemax, NC_FLOAT, 0, NULL);
if (ip->maxid < 0) {
FUNC_ERROR("micreate_std_variable");
}
/* Create the image-min variable.
*/
ip->minid = micreate_std_variable(ip->fd, MIimagemin, NC_FLOAT, 0, NULL);
if (ip->minid < 0) {
FUNC_ERROR("micreate_std_variable");
}
ip->imgid = micreate_std_variable(ip->fd, MIimage, NC_INT, ndims, ip->dim);
if (ip->imgid < 0) {
FUNC_ERROR("micreate_std_variable");
}
return (0);
}
int
test5(struct testinfo *ip, struct dimdef *dims, int ndims)
{
/* Get the same variable again, but this time use an ICV to scale it.
*/
size_t total;
long coords[3];
long lengths[3];
void *buf_ptr;
int *int_ptr;
int i, j, k;
int stat;
int icv;
total = 1;
total *= dims[TST_X].length;
total *= dims[TST_Y].length + YBOOST;
total *= dims[TST_Z].length + ZBOOST;
buf_ptr = malloc(total * sizeof (int));
if (buf_ptr == NULL) {
fprintf(stderr, "Oops, malloc failed\n");
return (-1);
}
icv = miicv_create();
if (icv < 0) {
FUNC_ERROR("miicv_create");
}
/* Now set up a dimension conversion. */
stat = miicv_setint(icv, MI_ICV_DO_NORM, 0);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_DO_RANGE, 0);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_TYPE, NC_INT);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_YDIM_DIR, MI_ICV_NEGATIVE);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_ZDIM_DIR, MI_ICV_NEGATIVE);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_BDIM_SIZE, dims[TST_Y].length + YBOOST);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_ADIM_SIZE, dims[TST_Z].length + ZBOOST);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_DO_DIM_CONV, 1);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_attach(icv, ip->fd, ip->imgid);
if (stat < 0) {
FUNC_ERROR("miicv_attach");
}
coords[TST_X] = 0;
coords[TST_Y] = 0;
coords[TST_Z] = 0;
lengths[TST_X] = dims[TST_X].length;
lengths[TST_Y] = dims[TST_Y].length + YBOOST;
lengths[TST_Z] = dims[TST_Z].length + ZBOOST;
stat = miicv_get(icv, coords, lengths, buf_ptr);
if (stat < 0) {
FUNC_ERROR("miicv_get");
}
int_ptr = (int *) buf_ptr;
for (i = 0; i < dims[TST_X].length; i++) {
for (j = 0; j < dims[TST_Y].length + YBOOST; j++) {
for (k = 0; k < dims[TST_Z].length + ZBOOST; k++, int_ptr++) {
int x;
int y;
int z;
int tmp;
if (j < YBOOST/2 || j >= dims[TST_Y].length + YBOOST/2)
continue;
if (k < ZBOOST/2 || k >= dims[TST_Z].length + ZBOOST/2)
continue;
x = i;
y = (YSIZE + YBOOST - 1) - j;
z = (ZSIZE + ZBOOST - 1) - k;
y -= YBOOST / 2;
z -= ZBOOST / 2;
tmp = (x * 10000) + (y * 100) + (z);
if (*int_ptr != (int) tmp) {
fprintf(stderr, "3. Data error at (%d,%d,%d) %d != %d\n",
i,j,k, *int_ptr, tmp);
errors++;
}
}
}
}
stat = miicv_detach(icv);
if (stat < 0) {
FUNC_ERROR("miicv_detach");
}
stat = miicv_free(icv);
if (stat < 0) {
FUNC_ERROR("miicv_free");
}
free(buf_ptr);
return (0);
}
int
test4(struct testinfo *ip, struct dimdef *dims, int ndims)
{
/* Get the same variable again, but this time use an ICV to scale it.
*/
size_t total;
long coords[3];
long lengths[3];
double range[2];
void *buf_ptr;
float *flt_ptr;
int i, j, k;
int stat;
int icv;
double dbl;
total = 1;
for (i = 0; i < ndims; i++) {
total *= dims[i].length;
}
buf_ptr = malloc(total * sizeof (float));
if (buf_ptr == NULL) {
fprintf(stderr, "Oops, malloc failed\n");
return (-1);
}
coords[TST_X] = 0;
coords[TST_Y] = 0;
coords[TST_Z] = 0;
lengths[TST_X] = dims[TST_X].length;
lengths[TST_Y] = dims[TST_Y].length;
lengths[TST_Z] = dims[TST_Z].length;
icv = miicv_create();
if (icv < 0) {
FUNC_ERROR("miicv_create");
}
stat = miicv_setint(icv, MI_ICV_TYPE, NC_FLOAT);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_DO_NORM, 1);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_attach(icv, ip->fd, ip->imgid);
if (stat < 0) {
FUNC_ERROR("miicv_attach");
}
/* This next call _should_ fail, since the ICV has been attached.
*/
stat = miicv_setint(icv, MI_ICV_DO_NORM, 0);
if (stat >= 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_inqdbl(icv, MI_ICV_DO_NORM, &dbl);
if (stat < 0) {
FUNC_ERROR("miicv_inqdbl");
}
if (dbl != 1.0) {
fprintf(stderr, "miicv_inqdbl: Bad value returned\n");
errors++;
}
stat = miicv_get(icv, coords, lengths, buf_ptr);
if (stat < 0) {
FUNC_ERROR("miicv_get");
}
stat = miget_image_range(ip->fd, range);
if (stat < 0) {
FUNC_ERROR("miget_image_range");
}
if (range[0] != -(XSIZE * 100000.0) || range[1] != (XSIZE * 100000.00)) {
fprintf(stderr, "miget_image_range: bad result\n");
errors++;
}
stat = miget_valid_range(ip->fd, ip->imgid, range);
if (stat < 0) {
FUNC_ERROR("miget_valid_range");
}
if (range[0] != -(XSIZE * 10000.0) || range[1] != (XSIZE * 10000.0)) {
fprintf(stderr, "miget_valid_range: bad result\n");
errors++;
}
flt_ptr = (float *) buf_ptr;
for (i = 0; i < dims[TST_X].length; i++) {
for (j = 0; j < dims[TST_Y].length; j++) {
for (k = 0; k < dims[TST_Z].length; k++) {
float tmp = (i * 10000) + (j * 100) + k;
if (*flt_ptr != (float) tmp * 10.0) {
fprintf(stderr, "2. Data error at (%d,%d,%d) %f != %f\n",
i,j,k, *flt_ptr, tmp);
errors++;
}
flt_ptr++;
}
}
}
stat = miicv_detach(icv);
if (stat < 0) {
FUNC_ERROR("miicv_detach");
}
/* Try it again, to make certain we fail gracefully.
*/
stat = miicv_detach(icv);
if (stat < 0) {
FUNC_ERROR("miicv_detach");
}
/* Try to detach a completely random number.
*/
stat = miicv_detach(rand());
if (stat >= 0) {
FUNC_ERROR("miicv_detach");
}
stat = miicv_free(icv);
if (stat < 0) {
FUNC_ERROR("miicv_free");
}
free(buf_ptr);
return (0);
}