/****************************************************************************
* NCSA HDF *
* Software Development Group *
* National Center for Supercomputing Applications *
* University of Illinois at Urbana-Champaign *
* 605 E. Springfield, Champaign IL 61820 *
* *
* For conditions of distribution and use, see the accompanying *
* hdf/COPYING file. *
* *
****************************************************************************/
/****************************************************************************
* temptySDS.c - tests the API SDcheckempty.
* Structure of the file:
* test_checkempty - test driver
* test_nonspecial_SDSs - tests nonspecial SDSs without closing file
* test_compressed_SDSs - tests compressed SDSs without closing file
* test_chunked_SDSs - tests chunked SDSs without closing file
* test_unlimited_SDSs - tests unlimited dim SDSs without closing file
* test_SDSs_infile - tests all SDSs in file after closing the file
* and reopening it
* check_SDS - utility routine that calls SDcheckempty and verifies values
****************************************************************************/
#include "mfhdf.h"
#ifdef HDF
#include "hdftest.h"
#define FILE_NAME "emptySDSs.hdf" /* data file to test empty SDSs */
#define X_LENGTH 10
#define Y_LENGTH 10
#define RANK 2
/* Utility routine that selects that named SDS, then calls SDcheckempty
* and verifies the returned values. */
static void check_SDS(
int32 fid, /* file id */
char* sds_name, /* name of the inquired SDS */
int32 check_value, /* expected ret val from SDcheckempty */
int32 verify_value, /* expected value of 'emptySDS' from SDcheckempty */
int* ret_num_errs /* current number of errors */ )
{
int32 sds_id, sds_index, status_32;
intn status, emptySDS;
int num_errs = 0;
char mesg[80];
/* Get index of dataset using its name */
sds_index = SDnametoindex(fid, sds_name);
sprintf(mesg, "In check_SDS: SDnametoindex (%s)", sds_name);
CHECK(sds_index, FAIL, mesg);
/* Select the dataset */
sds_id = SDselect(fid, sds_index);
CHECK(sds_id, FAIL, "In check_SDS: SDselect");
/* The returned value from SDcheckempty is CHECKed against
check_value (FAIL) and 'emptySDS' is verified to be verify_value,
which can be TRUE or FALSE. */
status_32 = SDcheckempty( sds_id, &emptySDS);
CHECK(status_32, check_value, "SDcheckempty");
VERIFY(emptySDS, verify_value, "SDcheckempty");
/* Close this SDS */
status = SDendaccess(sds_id);
CHECK(status, FAIL, "In check_SDS: SDendaccess");
*ret_num_errs = num_errs;
} /* check_SDS */
/* Test non-special SDSs. This routine creates non-special SDSs, writes
* data to one of the SDSs, and checks for emptiness on each without closing
* the file. */
static intn
test_nonspecial_SDSs(int32 fid)
{
int32 sds_id;
int32 dimsize[2], start[2], edges[2];
int32 data[Y_LENGTH][X_LENGTH];
intn status;
int i, j;
int num_errs = 0; /* number of errors so far */
/* Initialize data for the dataset */
for (j = 0; j < Y_LENGTH; j++) {
for (i = 0; i < X_LENGTH; i++)
data[j][i] = (i + j) + 1;
}
/* Create a 2x2 dataset called "EmptyDataset" */
dimsize[0] = Y_LENGTH;
dimsize[1] = X_LENGTH;
sds_id = SDcreate(fid, "EmptyDataset", DFNT_FLOAT32, 2, dimsize);
CHECK(sds_id, FAIL, "In test_nonspecial_SDSs: SDcreate 'EmptyDataset'");
/* Close this SDS */
status = SDendaccess(sds_id);
CHECK(status, FAIL, "In test_nonspecial_SDSs: SDendaccess");
/* Check that this SDS is empty */
check_SDS(fid, "EmptyDataset", FAIL, TRUE, &num_errs);
/* Create another 2x2 dataset called "WrittenDataset" */
sds_id = SDcreate(fid, "WrittenDataset", DFNT_INT32, 2, dimsize);
CHECK(sds_id, FAIL, "In test_nonspecial_SDSs: SDcreate 'WrittenDataset'");
/* Define the location and size of the data to be written to the dataset */
start[0] = 0;
start[1] = 0;
edges[0] = Y_LENGTH;
edges[1] = X_LENGTH;
/* Write the stored data to the dataset */
status = SDwritedata(sds_id, start, NULL, edges, (VOIDP)data);
CHECK(sds_id, FAIL, "In test_nonspecial_SDSs: SDwritedata");
/* Close this SDS */
status = SDendaccess(sds_id);
CHECK(status, FAIL, "In test_nonspecial_SDSs: SDendaccess");
/* Check that this SDS is NOT empty */
check_SDS(fid, "WrittenDataset", FAIL, FALSE, &num_errs);
/* Return the number of errors that's been kept track of so far */
return num_errs;
} /* test_nonspecial_SDSs */
/* Test compressed SDSs. This routine creates compressed SDSs, writes
* data to one of the SDSs, and checks for emptiness on each without closing
* the file. */
static intn
test_compressed_SDSs(int32 fid)
{
int32 sds_id, esds_id;
int32 start[2], edges[2], dim_sizes[2];
int32 comp_type; /* Compression flag */
comp_info c_info; /* Compression structure */
int32 data[Y_LENGTH][X_LENGTH];
intn status;
int i, j;
int num_errs = 0; /* number of errors so far */
/* Buffer array data and define array dimensions */
for (j = 0; j < Y_LENGTH; j++)
{
for (i = 0; i < X_LENGTH; i++)
data[j][i] = (i + j) + 1;
}
dim_sizes[0] = Y_LENGTH;
dim_sizes[1] = X_LENGTH;
/* Create datasets, one to be written with data, the other not */
sds_id = SDcreate(fid, "CompressedData", DFNT_INT32, RANK, dim_sizes);
CHECK(sds_id, FAIL, "In test_compressed_SDSs: SDcreate 'CompressedData'");
esds_id = SDcreate(fid, "Compressed-No-Data", DFNT_INT32, RANK, dim_sizes);
CHECK(esds_id, FAIL, "In test_compressed_SDSs: SDcreate 'Compressed-No-Data'");
comp_type = COMP_CODE_DEFLATE;
c_info.deflate.level = 6;
status = SDsetcompress(sds_id, comp_type, &c_info);
CHECK(status, FAIL, "In test_compressed_SDSs: SDsetcompress 'CompressedData'");
status = SDsetcompress(esds_id, comp_type, &c_info);
CHECK(status, FAIL, "In test_compressed_SDSs: SDsetcompress 'Compressed-No-Data'");
/* Define the location and size of the dataset to be written to the file */
start[0] = 0;
start[1] = 0;
edges[0] = Y_LENGTH;
edges[1] = X_LENGTH;
/* Write the stored data to the dataset */
status = SDwritedata(sds_id, start, NULL, edges, (VOIDP)data);
CHECK(status, FAIL, "In test_compressed_SDSs: SDwritedata");
/* Close the SDSs */
status = SDendaccess(sds_id);
CHECK(status, FAIL, "In test_compressed_SDSs: SDendaccess 'CompressedData'");
status = SDendaccess(esds_id);
CHECK(status, FAIL, "In test_compressed_SDSs: SDendaccess 'Compressed-No-Data'");
/* Check that this SDS is NOT empty */
check_SDS(fid, "CompressedData", FAIL, FALSE, &num_errs);
/* Check that this SDS is empty */
check_SDS(fid, "Compressed-No-Data", FAIL, TRUE, &num_errs);
/* Return the number of errors that's been kept track of so far */
return num_errs;
} /* test_compressed_SDSs */
/* Test chunked SDSs. This routine creates chunked SDSs, writes data
* to one of the SDSs, and checks for emptiness on each without closing
* the file. */
#define X_CHUNKED_LENGTH 4
#define Y_CHUNKED_LENGTH 9
static intn
test_chunked_SDSs(int32 fid)
{
int32 sds_id, esds_id, sds_index;
int32 flag, maxcache, new_maxcache;
int32 dim_sizes[RANK], origin[RANK];
HDF_CHUNK_DEF c_def; /* Chunking definitions */
int32 comp_flag;
int16 fill_value = 0; /* Fill value */
intn status;
int num_errs = 0; /* number of errors so far */
/* Declare chunks data type and initialize some of them. */
int16 chunk1[3][2] = { 1, 1,
1, 1,
1, 1 };
int16 chunk2[3][2] = { 2, 2,
2, 2,
2, 2 };
int16 chunk3[3][2] = { 3, 3,
3, 3,
3, 3 };
int16 chunk6[3][2] = { 6, 6,
6, 6,
6, 6 };
c_def.chunk_lengths[0] = 3;
c_def.chunk_lengths[1] = 2;
/* Create Y_CHUNKED_LENGTH x X_CHUNKED_LENGTH SDS */
dim_sizes[0] = Y_CHUNKED_LENGTH;
dim_sizes[1] = X_CHUNKED_LENGTH;
esds_id = SDcreate(fid, "Chunked-No-Data", DFNT_INT16, RANK, dim_sizes);
CHECK(esds_id, FAIL, "In test_chunked_SDSs: SDcreate 'Chunked-No-Data'");
/* Terminate access to the "Chunked-No-Data" dataset */
status = SDendaccess(esds_id);
CHECK(status, FAIL, "In test_chunked_SDSs: SDendaccess 'Chunked-No-Data'");
/* Check that this SDS is empty */
check_SDS(fid, "Chunked-No-Data", FAIL, TRUE, &num_errs);
/* Create another Y_CHUNKED_LENGTH x X_CHUNKED_LENGTH SDS but this
one will be written with chunks */
sds_id = SDcreate(fid, "ChunkedData", DFNT_INT16, RANK, dim_sizes);
CHECK(sds_id, FAIL, "In test_chunked_SDSs: SDcreate 'ChunkedData'");
/* Fill the SDS array with the fill value */
status = SDsetfillvalue(sds_id, (VOIDP)&fill_value);
CHECK(status, FAIL, "In test_chunked_SDSs: SDsetfillvalue");
/* Set info for chunking */
comp_flag = HDF_CHUNK;
status = SDsetchunk(sds_id, c_def, comp_flag);
CHECK(status, FAIL, "In test_chunked_SDSs: SDsetchunk");
/* Set chunk cache to hold maximum of 3 chunks */
maxcache = 3;
flag = 0;
new_maxcache = SDsetchunkcache(sds_id, maxcache, flag);
CHECK(new_maxcache, FAIL, "In test_chunked_SDSs: SDsetchunkcache");
/* Terminate access to the dataset then check if it's empty - and it
should be, before writing data to it. */
status = SDendaccess(sds_id);
CHECK(status, FAIL, "In test_chunked_SDSs: SDendaccess");
/* Check that this SDS is still empty after the call to SDsetchunk */
check_SDS(fid, "ChunkedData", FAIL, TRUE, &num_errs);
/* Re-select the "ChunkedData" SDS, then write chunks using SDwritechunk
function */
/* Get index of dataset using its name */
sds_index = SDnametoindex(fid, "ChunkedData");
CHECK(sds_index, FAIL, "In test_chunked_SDSs: SDnametoindex");
/* Select the dataset */
sds_id = SDselect(fid, sds_index);
CHECK(sds_id, FAIL, "In test_chunked_SDSs: SDselect");
/* Write the chunk with the coordinates (0,0) */
origin[0] = 0;
origin[1] = 0;
status = SDwritechunk(sds_id, origin, (VOIDP) chunk1);
CHECK(status, FAIL, "In test_chunked_SDSs: SDwritechunk");
/* Write the chunk with the coordinates (1,0) */
origin[0] = 1;
origin[1] = 0;
status = SDwritechunk(sds_id, origin, (VOIDP) chunk3);
CHECK(status, FAIL, "In test_chunked_SDSs: SDwritechunk");
/* Write the chunk with the coordinates (0,1) */
origin[0] = 0;
origin[1] = 1;
status = SDwritechunk(sds_id, origin, (VOIDP) chunk2);
CHECK(status, FAIL, "In test_chunked_SDSs: SDwritechunk");
/* Terminate access to the dataset */
status = SDendaccess(sds_id);
CHECK(status, FAIL, "In test_chunked_SDSs: SDendaccess");
/* Check that this SDS is NOT empty */
check_SDS(fid, "ChunkedData", FAIL, FALSE, &num_errs);
/* Return the number of errors that's been kept track of so far */
return num_errs;
} /* test_chunked_SDSs */
/* Test unlimited dimension SDSs. This routine creates unlimited
* dimension SDSs, writes data to one of the SDSs, and checks for
* emptiness on each without closing the file. */
static intn
test_unlimited_SDSs(int32 fid)
{
int32 sds_id, esds_id, sds_index;
int32 dim_sizes[2];
int32 data[Y_LENGTH][X_LENGTH], append_data[X_LENGTH];
int32 start[2], edges[2];
intn status;
int i, j;
int num_errs = 0; /* number of errors so far */
/* Data initialization */
for (j = 0; j < Y_LENGTH; j++)
{
for (i = 0; i < X_LENGTH; i++)
data[j][i] = (i + 1) + (j + 1);
}
/* Define dimensions of the array. Make the first dimension
appendable by defining its length to be unlimited */
dim_sizes[0] = SD_UNLIMITED;
dim_sizes[1] = X_LENGTH;
/* Create the array datasets */
esds_id = SDcreate(fid, "Appendable-No-Data", DFNT_INT32, RANK, dim_sizes);
CHECK(esds_id, FAIL, "In test_unlimited_SDSs: SDcreate 'Appendable-No-Data'");
sds_id = SDcreate(fid, "AppendableData", DFNT_INT32, RANK, dim_sizes);
CHECK(sds_id, FAIL, "In test_unlimited_SDSs: SDcreate 'AppendableData'");
/* Terminate access to the dataset "Appendable-No-Data" */
status = SDendaccess(esds_id);
/* Define the location and the size of the data to be written
to the second dataset */
start[0] = start[1] = 0;
edges[0] = Y_LENGTH;
edges[1] = X_LENGTH;
/* Write the data */
status = SDwritedata(sds_id, start, NULL, edges, (VOIDP)data);
CHECK(status, FAIL, "In test_unlimited_SDSs: SDwritedata");
/* Terminate access to the unlimited dataset */
status = SDendaccess(sds_id);
CHECK(status, FAIL, "In test_unlimited_SDSs: SDendaccess");
/* Check that this SDS is NOT empty */
check_SDS(fid, "AppendableData", FAIL, FALSE, &num_errs);
/* Store the array values to be appended to the dataset */
for (i = 0; i < X_LENGTH; i++)
append_data[i] = 1000 + i;
/* Get index of the dataset using its name */
sds_index = SDnametoindex(fid, "AppendableData");
CHECK(sds_index, FAIL, "In test_unlimited_SDSs: SDnametoindex");
/* Select the "AppendableData" dataset */
sds_id = SDselect(fid, sds_index);
CHECK(sds_id, FAIL, "In test_unlimited_SDSs: SDselect 'AppendableData'");
/* Check if selected SDS is unlimited. If it is not, then terminate
access to the SDS */
if (SDisrecord(sds_id))
{
/* Define the location of the append to start at the first column
* of the 11th row of the dataset and to stop at the end of the
* eleventh row. */
start[0] = Y_LENGTH;
start[1] = 0;
edges[0] = 1;
edges[1] = X_LENGTH;
/* Append data to the dataset */
status = SDwritedata(sds_id, start, NULL, edges, (VOIDP)append_data);
CHECK(status, FAIL, "In test_unlimited_SDSs: SDwritedata");
}
/* Terminate access to the dataset */
status = SDendaccess(sds_id);
CHECK(status, FAIL, "In test_unlimited_SDSs: SDendaccess");
/* Check that this SDS is NOT empty */
check_SDS(fid, "AppendableData", FAIL, FALSE, &num_errs);
/* Check that this SDS is empty */
check_SDS(fid, "Appendable-No-Data", FAIL, TRUE, &num_errs);
/* Return the number of errors that's been kept track of so far */
return num_errs;
} /* test_unlimited_SDSs */
/* This function checks which of the SDSs in the file are empty/written,
* just as in the previous individual tests. The difference is these
* SDSs are read back in after the file is closed and reopened. */
static intn
test_SDSs_infile()
{
int32 fid;
intn status;
int num_errs = 0; /* number of errors so far */
/* Open the file and initialize the SD interface */
fid = SDstart(FILE_NAME, DFACC_READ);
CHECK(fid, FAIL, "In test_SDSs_infile: SDstart");
/* Check that SDS named "EmptyDataset" is empty */
check_SDS(fid, "EmptyDataset", FAIL, TRUE, &num_errs);
/* Check that SDS named "AppendableData" is NOT empty */
check_SDS(fid, "AppendableData", FAIL, FALSE, &num_errs);
/* Check that SDS named "Appendable-No-Data" is empty */
check_SDS(fid, "Appendable-No-Data", FAIL, TRUE, &num_errs);
/* Check that SDS named "CompressedData" is NOT empty */
check_SDS(fid, "CompressedData", FAIL, FALSE, &num_errs);
/* Check that SDS named "Compressed-No-Data" is empty */
check_SDS(fid, "Compressed-No-Data", FAIL, TRUE, &num_errs);
/* Check that SDS named "ChunkedData" is NOT empty */
check_SDS(fid, "ChunkedData", FAIL, FALSE, &num_errs);
/* Check that SDS named "Chunked-No-Data" is empty */
check_SDS(fid, "Chunked-No-Data", FAIL, TRUE, &num_errs);
/* Close the file */
status = SDend(fid);
CHECK(status, FAIL, "In test_SDSs_infile: SDend");
/* Return the number of errors that's been kept track of so far */
return num_errs;
} /* test_SDSs_infile */
/* Test drive for testing the API SDcheckempty. */
extern int
test_checkempty()
{
int32 fid;
intn status;
int num_errs = 0;
/* Open the file and initialize the SD interface */
fid = SDstart(FILE_NAME, DFACC_CREATE);
CHECK(fid, FAIL, "In test_checkempty: SDstart");
num_errs = num_errs + test_nonspecial_SDSs(fid);
num_errs = num_errs + test_compressed_SDSs(fid);
num_errs = num_errs + test_chunked_SDSs(fid);
num_errs = num_errs + test_unlimited_SDSs(fid);
/* Close the file */
status = SDend(fid);
CHECK(status, FAIL, "In test_checkempty: SDend");
/* This function will reopen the file and check the SDSs in it */
num_errs = num_errs + test_SDSs_infile();
return num_errs;
}
#endif /* HDF */
syntax highlighted by Code2HTML, v. 0.9.1