int
main(int argc, char **argv)
{
int mpi_namelen;
char mpi_name[MPI_MAX_PROCESSOR_NAME];
int mpi_size, mpi_rank;
MPI_Comm comm = MPI_COMM_WORLD;
MPI_Info info = MPI_INFO_NULL;
double start_time = 0, total_time;
int mpi_size_in;
#define NUM_TEST_TYPES 11
nc_type test_type[NUM_TEST_TYPES] = {NC_BYTE, NC_CHAR, NC_SHORT, NC_INT, NC_FLOAT, NC_DOUBLE,
NC_UBYTE, NC_USHORT, NC_UINT, NC_INT64, NC_UINT64};
int tt, fv;
int j, i, k, ret;
/* Initialize MPI. */
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Get_processor_name(mpi_name, &mpi_namelen);
/* Must be able to evenly divide my slabs between processors. */
if (NUM_SLABS % mpi_size)
{
if (!mpi_rank)
printf("NUM_SLABS (%d) is not evenly divisible by mpi_size(%d)\n",
NUM_SLABS, mpi_size);
ERR;
}
if (!mpi_rank)
printf("\n*** Testing parallel I/O some more.\n");
/* Test for different fill value settings. */
for (fv = 0; fv < NUM_FILL_TEST_RUNS; fv++)
{
/* Test for different netCDF types. */
for (tt = 0; tt < NUM_TEST_TYPES; tt++)
{
char file_name[NC_MAX_NAME + 1];
int fill_mode_in;
void *data, *data_in;
void *fill_value, *fill_value_in;
size_t type_size;
size_t write_start[NDIMS] = {0, 0, 1};
size_t write_count[NDIMS] = {1, DIMSIZE, DIMSIZE - 1};
size_t read_start[NDIMS] = {0, 0, 0};
size_t read_count[NDIMS] = {1, DIMSIZE, DIMSIZE};
int ncid, varid, dimids[NDIMS];
int ndims_in, nvars_in, natts_in, unlimdimid_in;
/* Fill values to be expected. */
signed char byte_expected_fill_value;
unsigned char char_expected_fill_value;
short short_expected_fill_value;
int int_expected_fill_value;
float float_expected_fill_value;
double double_expected_fill_value;
unsigned char ubyte_expected_fill_value;
unsigned short ushort_expected_fill_value;
unsigned int uint_expected_fill_value;
long long int int64_expected_fill_value;
unsigned long long int uint64_expected_fill_value;
/* Fill values used when writing. */
signed char byte_fill_value = -TEST_VAL_42;
unsigned char char_fill_value = 'x';
short short_fill_value = TEST_VAL_42 * 100;
int int_fill_value = TEST_VAL_42 * 1000;
float float_fill_value = TEST_VAL_42 * 1000;
double double_fill_value = TEST_VAL_42 * 1000;
unsigned char ubyte_fill_value = TEST_VAL_42;
unsigned short ushort_fill_value = TEST_VAL_42 * 100;
unsigned int uint_fill_value = TEST_VAL_42 * 1000;
long long int int64_fill_value = TEST_VAL_42 * 1000;
unsigned long long int uint64_fill_value = TEST_VAL_42 * 1000;
/* Fill values read in. */
signed char byte_fill_value_in;
unsigned char char_fill_value_in;
short short_fill_value_in;
int int_fill_value_in;
float float_fill_value_in;
double double_fill_value_in;
unsigned char ubyte_fill_value_in;
unsigned short ushort_fill_value_in;
unsigned int uint_fill_value_in;
long long int int64_fill_value_in;
unsigned long long int uint64_fill_value_in;
/* Data to write and read. */
signed char byte_data[DIMSIZE * DIMSIZE], byte_data_in[DIMSIZE * DIMSIZE];
unsigned char char_data[DIMSIZE * DIMSIZE], char_data_in[DIMSIZE * DIMSIZE];
short short_data[DIMSIZE * DIMSIZE], short_data_in[DIMSIZE * DIMSIZE];
int int_data[DIMSIZE * DIMSIZE], int_data_in[DIMSIZE * DIMSIZE];
float float_data[DIMSIZE * DIMSIZE], float_data_in[DIMSIZE * DIMSIZE];
double double_data[DIMSIZE * DIMSIZE], double_data_in[DIMSIZE * DIMSIZE];
unsigned char ubyte_data[DIMSIZE * DIMSIZE], ubyte_data_in[DIMSIZE * DIMSIZE];
unsigned short ushort_data[DIMSIZE * DIMSIZE], ushort_data_in[DIMSIZE * DIMSIZE];
unsigned int uint_data[DIMSIZE * DIMSIZE], uint_data_in[DIMSIZE * DIMSIZE];
long long int int64_data[DIMSIZE * DIMSIZE], int64_data_in[DIMSIZE * DIMSIZE];
unsigned long long int uint64_data[DIMSIZE * DIMSIZE], uint64_data_in[DIMSIZE * DIMSIZE];
if (!mpi_rank)
printf("*** writing a %d x %d x %d file from %d processors for fill value test %d type %d...\n",
NUM_SLABS, DIMSIZE, DIMSIZE, mpi_size, fv, test_type[tt]);
/* Initialize test data. */
switch(test_type[tt])
{
case NC_BYTE:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
byte_data[i] = mpi_rank;
data = byte_data;
data_in = byte_data_in;
byte_expected_fill_value = fv ? byte_fill_value : NC_FILL_BYTE;
fill_value = &byte_expected_fill_value;
fill_value_in = &byte_fill_value_in;
break;
case NC_CHAR:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
char_data[i] = mpi_rank;
data = char_data;
data_in = char_data_in;
char_expected_fill_value = fv ? char_fill_value : NC_FILL_CHAR;
fill_value = &char_expected_fill_value;
fill_value_in = &char_fill_value_in;
break;
case NC_SHORT:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
short_data[i] = mpi_rank;
data = short_data;
data_in = short_data_in;
short_expected_fill_value = fv ? short_fill_value : NC_FILL_SHORT;
fill_value = &short_expected_fill_value;
fill_value_in = &short_fill_value_in;
break;
case NC_INT:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
int_data[i] = mpi_rank;
data = int_data;
data_in = int_data_in;
int_expected_fill_value = fv ? int_fill_value : NC_FILL_INT;
fill_value = &int_expected_fill_value;
fill_value_in = &int_fill_value_in;
break;
case NC_FLOAT:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
float_data[i] = mpi_rank;
data = float_data;
data_in = float_data_in;
float_expected_fill_value = fv ? float_fill_value : NC_FILL_FLOAT;
fill_value = &float_expected_fill_value;
fill_value_in = &float_fill_value_in;
break;
case NC_DOUBLE:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
double_data[i] = mpi_rank;
data = double_data;
data_in = double_data_in;
double_expected_fill_value = fv ? double_fill_value : NC_FILL_DOUBLE;
fill_value = &double_expected_fill_value;
fill_value_in = &double_fill_value_in;
break;
case NC_UBYTE:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
ubyte_data[i] = mpi_rank;
data = ubyte_data;
data_in = ubyte_data_in;
ubyte_expected_fill_value = fv ? ubyte_fill_value : NC_FILL_UBYTE;
fill_value = &ubyte_expected_fill_value;
fill_value_in = &ubyte_fill_value_in;
break;
case NC_USHORT:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
ushort_data[i] = mpi_rank;
data = ushort_data;
data_in = ushort_data_in;
ushort_expected_fill_value = fv ? ushort_fill_value : NC_FILL_USHORT;
fill_value = &ushort_expected_fill_value;
fill_value_in = &ushort_fill_value_in;
break;
case NC_UINT:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
uint_data[i] = mpi_rank;
data = uint_data;
data_in = uint_data_in;
uint_expected_fill_value = fv ? uint_fill_value : NC_FILL_UINT;
fill_value = &uint_expected_fill_value;
fill_value_in = &uint_fill_value_in;
break;
case NC_INT64:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
int64_data[i] = mpi_rank;
data = int64_data;
data_in = int64_data_in;
int64_expected_fill_value = fv ? int64_fill_value : NC_FILL_INT64;
fill_value = &int64_expected_fill_value;
fill_value_in = &int64_fill_value_in;
break;
case NC_UINT64:
for (i = 0; i < DIMSIZE * DIMSIZE; i++)
uint64_data[i] = mpi_rank;
data = uint64_data;
data_in = uint64_data_in;
uint64_expected_fill_value = fv ? uint64_fill_value : NC_FILL_UINT64;
fill_value = &uint64_expected_fill_value;
fill_value_in = &uint64_fill_value_in;
break;
}
/* Create a file name. */
sprintf(file_name, "%s_type_%d_fv_%d.nc", TEST_NAME, test_type[tt], fv);
/* Create a parallel netcdf-4 file. */
if (nc_create_par(file_name, NC_NETCDF4, comm, info, &ncid)) ERR;
/* Get the type len. */
if (nc_inq_type(ncid, test_type[tt], NULL, &type_size)) ERR;
/* A global attribute holds the number of processors that created
* the file. */
if (nc_put_att_int(ncid, NC_GLOBAL, "num_processors", NC_INT, 1, &mpi_size)) ERR;
/* Create three dimensions. */
if (nc_def_dim(ncid, DIM1_NAME, NUM_SLABS, dimids)) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIMSIZE, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIMSIZE, &dimids[2])) ERR;
/* Create one var. */
if (nc_def_var(ncid, VAR_NAME, test_type[tt], NDIMS, dimids, &varid)) ERR;
if (nc_put_att_int(ncid, varid, "var_num_processors", NC_INT, 1, &mpi_size)) ERR;
if (fv == 1)
{
if (nc_def_var_fill(ncid, varid, NC_FILL, fill_value)) ERR;
if (nc_inq_var_fill(ncid, varid, &fill_mode_in, fill_value_in)) ERR;
if (fill_mode_in != NC_FILL) ERR;
if (memcmp(fill_value_in, fill_value, type_size)) ERR;
}
else if (fv == 2)
{
if (nc_def_var_fill(ncid, varid, NC_NOFILL, NULL)) ERR;
if (nc_inq_var_fill(ncid, varid, &fill_mode_in, NULL)) ERR;
if (!fill_mode_in) ERR; /* nofill will be true */
}
/* Write metadata to file. */
if (nc_enddef(ncid)) ERR;
/* Change access mode to collective, then back to independent. */
if (nc_var_par_access(ncid, varid, NC_COLLECTIVE)) ERR;
if (nc_var_par_access(ncid, varid, NC_INDEPENDENT)) ERR;
if (!mpi_rank)
start_time = MPI_Wtime();
/* Write all the slabs this process is responsible for. */
for (i = 0; i < NUM_SLABS / mpi_size; i++)
{
write_start[0] = NUM_SLABS / mpi_size * mpi_rank + i;
/* Write one slab of data. Due to start/count settings,
* every 16th value will be a fill value. */
if (nc_put_vara(ncid, varid, write_start, write_count, data)) ERR;
}
/* On rank 0, keep track of time. */
if (!mpi_rank)
{
total_time = MPI_Wtime() - start_time;
printf("%d\t%g\t%g\n", mpi_size, total_time, DIMSIZE * DIMSIZE * NUM_SLABS *
sizeof(int) / total_time);
}
/* Close the netcdf file. */
if (nc_close(ncid)) ERR;
/* Reopen the file and check it. */
if ((ret = nc_open_par(file_name, NC_NOWRITE, comm, info, &ncid))) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != NDIMS || nvars_in != 1 || natts_in != 1 ||
unlimdimid_in != -1) ERR;
/* Check the attributes. */
if (nc_get_att_int(ncid, NC_GLOBAL, "num_processors", &mpi_size_in)) ERR;
if (mpi_size_in != mpi_size) ERR;
if (nc_get_att_int(ncid, 0, "var_num_processors", &mpi_size_in)) ERR;
if (mpi_size_in != mpi_size) ERR;
if (fv == 1)
{
if (nc_inq_var_fill(ncid, varid, &fill_mode_in, fill_value_in)) ERR;
if (fill_mode_in != NC_FILL) ERR;
if (memcmp(fill_value_in, fill_value, type_size)) ERR;
}
/* Read all the slabs this process is responsible for. */
for (i = 0; i < NUM_SLABS / mpi_size; i++)
{
read_start[0] = NUM_SLABS / mpi_size * mpi_rank + i;
/* printf("mpi_rank %d i %d read_start[0] %ld\n", mpi_rank, i, read_start[0]); */
/* Read one slab of data. */
if (nc_get_vara(ncid, varid, read_start, read_count, data_in)) ERR;
/* Check data. For the third fill value test, fill is
* turned off. So don't bother testing the values where k
* is zero. */
/* printf("mpi_rank %d fv %d i %d j %d k %d int_data_in[j * k] %d int_expected_fill_value %d " */
/* "expected_value %d\n", mpi_rank, fv, i, j, k, int_data_in[j * k], */
/* int_expected_fill_value, expected_value); */
switch (test_type[tt])
{
case NC_BYTE:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (byte_data_in[j * DIMSIZE + k] != (signed char)(k ? mpi_rank : byte_expected_fill_value)) ERR;
break;
case NC_SHORT:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (short_data_in[j * DIMSIZE + k] != (short)(k ? mpi_rank : short_expected_fill_value)) ERR;
break;
case NC_INT:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (int_data_in[j * DIMSIZE + k] != (int)(k ? mpi_rank : int_expected_fill_value)) ERR;
break;
case NC_FLOAT:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (float_data_in[j * DIMSIZE + k] != (float)(k ? mpi_rank : float_expected_fill_value)) ERR;
break;
case NC_DOUBLE:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (double_data_in[j * DIMSIZE + k] != (double)(k ? mpi_rank : double_expected_fill_value)) ERR;
break;
case NC_UBYTE:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (ubyte_data_in[j * DIMSIZE + k] != (unsigned char)(k ? mpi_rank : ubyte_expected_fill_value)) ERR;
break;
case NC_USHORT:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (ushort_data_in[j * DIMSIZE + k] != (unsigned short)(k ? mpi_rank : ushort_expected_fill_value)) ERR;
break;
case NC_UINT:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (uint_data_in[j * DIMSIZE + k] != (unsigned int)(k ? mpi_rank : uint_expected_fill_value)) ERR;
break;
case NC_INT64:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (int64_data_in[j * DIMSIZE + k] != (long long int)(k ? mpi_rank : int64_expected_fill_value)) ERR;
break;
case NC_UINT64:
for (j = 0; j < DIMSIZE; j++)
for (k = 0; k < DIMSIZE; k++)
if (fv < 2 || k)
if (uint64_data_in[j * DIMSIZE + k] != (unsigned long long int)(k ? mpi_rank : uint64_expected_fill_value)) ERR;
break;
}
} /* next slab */
/* Close the netcdf file. */
if (nc_close(ncid)) ERR;
if (!mpi_rank)
SUMMARIZE_ERR;
} /* next test type */
} /* next fill value test run */
/* Shut down MPI. */
MPI_Finalize();
if (!mpi_rank)
FINAL_RESULTS;
return 0;
}
int
Ensemble::getTimes(std::string &str)
{
// reading netcdf files
int ncid, dimid, varid, status;
size_t recSize, len;
size_t index=0;
double val ;
int retVal=0;
std::string begStr;
std::string endStr;
for( size_t i=0 ; i < member.size() ; ++i )
{
if( nc_open( member[i]->getFile().c_str(), 0, &ncid) )
{
isInvalid = true;
member[i]->state = "could not open file";
continue;
}
nc_inq_unlimdim(ncid, &dimid) ;
if( dimid == -1 )
// try for a regular dimension time
nc_inq_dimid(ncid, "time", &dimid);
// no unlimited variable found; this is not
// neccessarily an error.
if( dimid == -1 )
{
isNoRec = true;
nc_close(ncid);
if( sz == 1 )
return 0; // a single file
else
retVal=4;
isInvalid = true;
member[i]->state += "missing time dimension";
continue;
}
if( (status = nc_inq_dimlen(ncid, dimid, &recSize) ) )
{
isInvalid = true;
member[i]->state = "could not read time dimension";
nc_close(ncid);
continue;
}
if( status == 0 && recSize == 0 )
{
// this could be wrong
// or just a fixed variable with time dimension defined.
isNoRec = true;
nc_close(ncid);
if( sz == 1 )
return 0;
isInvalid = true;
member[i]->state = "no time values available";
continue;
}
if( (status = nc_inq_varid(ncid, "time", &varid) ) )
{
isNoRec = true;
nc_close(ncid);
if( sz == 1 )
return 0;
member[i]->state = "missing time variable";
continue;
}
// reference calendar
std::vector<std::string> vs;
if( getAttText(ncid, varid, "calendar", vs) )
{ // failure
member[i]->state = "missing or invalid calendar attribute";
nc_close(ncid);
continue;
}
else
// successful reading of calendar
member[i]->refDate.setCalendar(vs[0]) ;
// reference date
if( getAttText(ncid, varid, "units", vs) )
{ // failure
member[i]->state = "missing or invalid units attribute";
nc_close(ncid);
continue;
}
else
{
if( vs[0].find("%Y") < std::string::npos )
member[i]->refDate.setFormattedDate();
else
member[i]->refDate = vs[0] ;
}
// time values: fist and last
index=0;
if( (status = nc_get_var1_double(ncid, varid, &index, &val) ) )
{
if( sz > 1 )
{
isInvalid = true;
member[i]->state = "could not read first time value";
nc_close(ncid);
continue;
}
}
// any reasonable values available?
nc_type var_type ;
status = nc_inq_vartype(ncid, varid, &var_type) ;
// return value type is double
double fV;
int noFill=0;
int statusF = nc_inq_var_fill(ncid, varid, &noFill, &fV);
if( noFill != 1 && (statusF || val == fV) )
{
isInvalid = true;
member[i]->state = "first time value equals _FillValue";
nc_close(ncid);
continue;
}
if(member[i]->refDate.isValid(val))
member[i]->setBegin( member[i]->refDate.getDate(val) );
else
{
isInvalid=true;
retVal=5;
member[i]->putState("invalid data, found " + hdhC::double2String(val), false);
nc_close(ncid);
continue;
}
index=recSize-1;
if( (status = nc_get_var1_double(ncid, varid, &index, &val) ) )
{
if( sz > 1 )
{
isInvalid = true;
member[i]->putState("could not read last time value");
nc_close(ncid);
}
}
if( noFill != 1 && (statusF || val == fV) )
{
isInvalid = true;
member[i]->putState("last time value equals _FillValue");
nc_close(ncid);
continue;
}
if(member[i]->refDate.isValid(val))
member[i]->setEnd( member[i]->refDate.getDate(val) );
else
{
isInvalid=true;
retVal=5;
member[i]->putState("invalid data, found " + hdhC::double2String(val), false);
}
nc_close(ncid);
}
// any serious conditions
if( isInvalid )
{
// only files with annotations
enablePrintOnlyMarked();
str = getOutput();
if( retVal )
return retVal;
else
return 3 ; // unspecific error
}
// get modification times of files
for(size_t i=0 ; i < member.size() ; ++i )
member[i]->getModificationTime() ;
// sorted vector of pointers of dates
sortDate();
return 0;
}
int
main(int argc, char **argv)
{
#ifdef USE_PARALLEL
MPI_Init(&argc, &argv);
#endif
int ncid, dimids[3];
int char_varid, byte_varid, ubyte_varid, short_varid, int_varid, float_varid, double_varid;
int ushort_varid, uint_varid, int64_varid, uint64_varid;
int i, j;
unsigned char ubyte_out[DIM1_LEN][DIM2_LEN] = {{1, 128, 255},{1, 128, 255}};
signed char byte_in[DIM1_LEN][DIM2_LEN], byte_out[DIM1_LEN][DIM2_LEN] = {{-127, 1, 127},{-127, 1, 127}};
unsigned short ushort_out[DIM1_LEN][DIM2_LEN] = {{110, 128, 255},{110, 128, 255}};
short short_in[DIM1_LEN][DIM2_LEN], short_out[DIM1_LEN][DIM2_LEN] = {{-110, -128, 255},{-110, -128, 255}};
int int_in[DIM1_LEN][DIM2_LEN], int_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
float float_in[DIM1_LEN][DIM2_LEN], float_out[DIM1_LEN][DIM2_LEN] = {{-.1, 9999.99, 100.001},{-.1, 9999.99, 100.001}};
double double_in[DIM1_LEN][DIM2_LEN], double_out[DIM1_LEN][DIM2_LEN] = {{0.02, .1128, 1090.1},{0.02, .1128, 1090.1}};
unsigned int uint_in[DIM1_LEN][DIM2_LEN], uint_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
long long int64_in[DIM1_LEN][DIM2_LEN], int64_out[DIM1_LEN][DIM2_LEN] = {{-111, 777, 100},{-111, 777, 100}};
unsigned long long uint64_in[DIM1_LEN][DIM2_LEN];
unsigned long long uint64_out[DIM1_LEN][DIM2_LEN] = {{0, 10101, 9999999},{0, 10101, 9999999}};
char char_out[DIM1_LEN][DIM2_LEN][DIM3_LEN] = {{"lalala", "lololo", "lelele"}, {"lalala", "lololo", "lelele"}};
/*nc_set_log_level(4);*/
printf("\n*** Testing netcdf-4 variable functions.\n");
printf("*** testing netcdf-4 varids inq on netcdf-3 file...");
{
int nvars_in, varids_in[2];
/* Create a netcdf-3 file with one dim and two vars. */
if (nc_create(FILE_NAME, 0, &ncid)) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and make sure nc_inq_varids yeilds correct
* result. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing simple variables...");
{
/* Create a file with a variable of each type. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR;
if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR;
if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR;
if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR;
if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR;
if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR;
if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR;
if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR;
if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR;
if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR;
if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR;
if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR;
if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR;
if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR;
if (nc_put_var_ubyte(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR;
if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR;
if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR;
if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR;
if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check metadata. */
{
nc_type xtype_in;
int ndims_in, dimids_in[10], natts_in, varid_in;
char name_in[NC_MAX_NAME+1];
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in,
&natts_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE ||
ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
dimids_in[1] != dimids[1]) ERR;
if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR;
if (varid_in != 1) ERR;
if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR;
if (varid_in != 2) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME)) ERR;
if (nc_inq_varname(ncid, 1, name_in)) ERR;
if (strcmp(name_in, VAR_CHAR_NAME)) ERR;
if (nc_inq_varname(ncid, 2, name_in)) ERR;
if (strcmp(name_in, VAR_SHORT_NAME)) ERR;
if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
if (xtype_in != NC_BYTE) ERR;
if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
if (xtype_in != NC_CHAR) ERR;
if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
if (xtype_in != NC_SHORT) ERR;
if (nc_close(ncid)) ERR;
}
/* Open the file and check data. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != byte_out[i][j]) ERR;
if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (short_in[i][j] != short_out[i][j]) ERR;
if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int_in[i][j] != int_out[i][j]) ERR;
if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (float_in[i][j] != float_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint_in[i][j] != uint_out[i][j]) ERR;
if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int64_in[i][j] != int64_out[i][j]) ERR;
if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint64_in[i][j] != uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as double. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)byte_out[i][j]) ERR;
if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)short_out[i][j]) ERR;
if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint_out[i][j]) ERR;
if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)float_out[i][j]) ERR;
if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int64_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as NC_BYTE. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define DEFLATE_LEVEL_4 4
printf("*** testing simple variables with deflation...");
{
/* Create a file with a variable of each type. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
if (nc_def_var_deflate(ncid, byte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
if (nc_def_var_deflate(ncid, byte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR;
if (nc_def_var_deflate(ncid, short_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR;
if (nc_def_var_deflate(ncid, int_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR;
if (nc_def_var_deflate(ncid, float_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR;
if (nc_def_var_deflate(ncid, double_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
if (nc_def_var_deflate(ncid, ubyte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR;
if (nc_def_var_deflate(ncid, ushort_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR;
if (nc_def_var_deflate(ncid, uint_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR;
if (nc_def_var_deflate(ncid, int64_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR;
if (nc_def_var_deflate(ncid, uint64_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR;
if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR;
if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR;
if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR;
if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR;
if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR;
if (nc_put_var_ubyte(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR;
if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR;
if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR;
if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR;
if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check metadata. */
{
nc_type xtype_in;
int ndims_in, dimids_in[10], natts_in, varid_in;
char name_in[NC_MAX_NAME+1];
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in,
&natts_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE ||
ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
dimids_in[1] != dimids[1]) ERR;
if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR;
if (varid_in != 1) ERR;
if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR;
if (varid_in != 2) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME)) ERR;
if (nc_inq_varname(ncid, 1, name_in)) ERR;
if (strcmp(name_in, VAR_CHAR_NAME)) ERR;
if (nc_inq_varname(ncid, 2, name_in)) ERR;
if (strcmp(name_in, VAR_SHORT_NAME)) ERR;
if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
if (xtype_in != NC_BYTE) ERR;
if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
if (xtype_in != NC_CHAR) ERR;
if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
if (xtype_in != NC_SHORT) ERR;
if (nc_close(ncid)) ERR;
}
/* Open the file and check data. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != byte_out[i][j]) ERR;
if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (short_in[i][j] != short_out[i][j]) ERR;
if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int_in[i][j] != int_out[i][j]) ERR;
if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (float_in[i][j] != float_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint_in[i][j] != uint_out[i][j]) ERR;
if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int64_in[i][j] != int64_out[i][j]) ERR;
if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint64_in[i][j] != uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as double. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)byte_out[i][j]) ERR;
if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)short_out[i][j]) ERR;
if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint_out[i][j]) ERR;
if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)float_out[i][j]) ERR;
if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int64_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as NC_BYTE. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NDIMS4 1
#define NVARS4 1
#define DIM4_NAME "treaty_of_paris_1783"
#define DIM4_LEN 5
#define VAR_NAME4 "John_Adams"
#define DEFLATE_LEVEL 6
printf("*** testing netcdf-4 simple variable define...");
{
int dimids[NDIMS4], dimids_in[NDIMS4];
int varid, varids_in[NVARS4];
int ndims, nvars, natts, unlimdimid;
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int shuffle_in, deflate_in, deflate_level;
/* Create a netcdf-4 file with one dim and one var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM4_NAME, DIM4_LEN, &dimids[0])) ERR;
if (dimids[0] != 0) ERR;
if (nc_def_var(ncid, VAR_NAME4, NC_INT64, NDIMS4, dimids, &varid)) ERR;
if (nc_def_var_deflate(ncid, varid, 0, 1, DEFLATE_LEVEL)) ERR;
if (varid != 0) ERR;
/* Check stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS4) ERR;
if (varids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level)) ERR;
if (shuffle_in ||!deflate_in ||
deflate_level != DEFLATE_LEVEL) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS4) ERR;
if (varids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level)) ERR;
if (shuffle_in ||!deflate_in ||
deflate_level != DEFLATE_LEVEL) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NDIMS5 1
#define NVARS5 5
#define DIM5_NAME "treaty_of_paris_1783"
#define DIM5_LEN 5
printf("*** testing netcdf-4 less simple variable define...");
{
int dimids[NDIMS5], dimids_in[NDIMS5];
int varid[NVARS5], varids_in[NVARS5];
int ndims, nvars, natts, unlimdimid;
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
char var_name[NVARS5][NC_MAX_NAME + 1] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
"Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
"Charles_F_Ritchel"};
int shuffle_in, deflate_in, deflate_level_in;
int deflate_level[NVARS5];
int i;
/* Set up options for this var. */
for (i = 0; i < NVARS5; i++)
deflate_level[i] = i;
/* Create a netcdf-4 file with one dim and two vars. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM5_NAME, DIM5_LEN, &dimids[0])) ERR;
if (dimids[0] != 0) ERR;
for (i = 0; i < NVARS5; i++)
{
if (nc_def_var(ncid, var_name[i], NC_INT64, NDIMS5, dimids,
&varid[i])) ERR;
if (varid[i] != i) ERR;
if (nc_def_var_deflate(ncid, varid[i], 1, 1, deflate_level[i])) ERR;
}
/* Check stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS5) ERR;
for (i = 0; i < NVARS5; i++)
{
if (varids_in[i] != i) ERR;
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (!shuffle_in || !deflate_in ||
deflate_level_in != deflate_level[i]) ERR;
}
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS5) ERR;
for (i = 0; i < NVARS5; i++)
{
if (varids_in[i] != i) ERR;
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (!shuffle_in || !deflate_in ||
deflate_level_in != deflate_level[i]) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NVARS 5
#define NDIMS 1
#define DIM6_NAME "airship_cross_sectional_area"
#define DIM6_LEN 100
#define TEN_K_M2 10000.0
#define INCREMENT 1000.0
printf("*** testing more complex netcdf-4 variable defines...");
{
int dimids[NDIMS], dimids_in[NDIMS];
int varid[NVARS], varids_in[NVARS];
int ndims, nvars, natts, unlimdimid;
char var_name[NVARS][50] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
"Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
"Charles_F_Ritchel"};
double data[DIM6_LEN];
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int shuffle_in, deflate_in, deflate_level_in;
int fletcher32_in;
int i;
/* Create some phoney data. */
for (i = 1, data[0] = TEN_K_M2; i < DIM6_LEN; i++)
data[i] = data[i - 1] + INCREMENT;
/* Create a netcdf-4 file with one dim and 5 NC_DOUBLE vars. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM6_NAME, DIM6_LEN, &dimids[0])) ERR;
for (i = 0; i < NVARS; i++)
{
if (nc_def_var(ncid, var_name[i], NC_DOUBLE, NDIMS, dimids,
&varid[i])) ERR;
if (nc_def_var_deflate(ncid, varid[i], 0, 1, 0)) ERR;
if (nc_def_var_fletcher32(ncid, varid[i], 1)) ERR;
}
/* Check stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS) ERR;
for (i = 0; i < NVARS; i++)
if (varids_in[i] != i) ERR;
for (i = 0; i < NVARS; i++)
{
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || !deflate_in || deflate_level_in != 0) ERR;
if (nc_inq_var_fletcher32(ncid, varid[i], &fletcher32_in)) ERR;
if (!fletcher32_in) ERR;
}
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS) ERR;
for (i = 0; i < NVARS; i++)
if (varids_in[i] != i) ERR;
for (i = 0; i < NVARS; i++)
{
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || !deflate_in ||
deflate_level_in != 0) ERR;
if (nc_inq_var_fletcher32(ncid, varid[i], &fletcher32_in)) ERR;
if (!fletcher32_in) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define DIM7_LEN 2
#define DIM7_NAME "dim_7_from_Indiana"
#define VAR7_NAME "var_7_from_Idaho"
#define NDIMS 1
printf("*** testing fill values...");
{
int dimids[NDIMS], dimids_in[NDIMS];
size_t index[NDIMS];
int varid, ndims, natts;
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int shuffle_in, deflate_in, deflate_level_in;
int fletcher32_in, no_fill;
unsigned short ushort_data = 42, ushort_data_in, fill_value_in;
/* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR;
if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids,
&varid)) ERR;
/* Check stuff. */
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || deflate_in) ERR;
if (nc_inq_var_fletcher32(ncid, 0, &fletcher32_in)) ERR;
if (fletcher32_in) ERR;
if (nc_inq_var_fill(ncid, 0, &no_fill, &fill_value_in)) ERR;
if (no_fill || fill_value_in != NC_FILL_USHORT) ERR;
/* Write the second of two values. */
index[0] = 1;
if (nc_put_var1_ushort(ncid, 0, index, &ushort_data)) ERR;
/* Get the first value, and make sure we get the default fill
* value for USHORT. */
index[0] = 0;
if (nc_get_var1_ushort(ncid, 0, index, &ushort_data_in)) ERR;
if (ushort_data_in != NC_FILL_USHORT) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check stuff. */
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || deflate_in) ERR;
if (nc_inq_var_fletcher32(ncid, 0, &fletcher32_in)) ERR;
if (fletcher32_in) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing more fill values...");
{
int dimids[NDIMS];
size_t index[NDIMS];
int varid;
int no_fill;
unsigned short ushort_data = 42, ushort_data_in, fill_value_in;
/* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR;
if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids,
&varid)) ERR;
if (nc_def_var_fill(ncid, varid, 1, NULL)) ERR;
/* Check stuff. */
if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
if (!no_fill) ERR;
/* Write the second of two values. */
index[0] = 1;
if (nc_put_var1_ushort(ncid, varid, index, &ushort_data)) ERR;
/* Get the first value, and make sure we get the default fill
* value for USHORT. */
index[0] = 0;
if (nc_get_var1_ushort(ncid, varid, index, &ushort_data_in)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check stuff. */
if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
if (!no_fill) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing lots of variables...");
#define DIM_A_NAME "x"
#define DIM_A_LEN 10
#define NUM_VARS 2000
#define MAX_VARNAME 10
{
/* This simple test failed on HDF5 1.7.58, but passes just fine
* on 1.8.0 alpha5... */
int ncid, dimids[1], i;
char varname[MAX_VARNAME];
int varids[NUM_VARS];
/* Create a file with three dimensions. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_A_NAME, DIM_A_LEN, &dimids[0])) ERR;
/* Create a large number of variables. */
for (i = 0; i < NUM_VARS; i++)
{
sprintf(varname, "a_%d", i);
if (nc_def_var(ncid, varname, NC_FLOAT, 1, dimids, &varids[i])) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NC3_CLASSIC_FILE "tst_pres_temp_4D_classic.nc"
#define NC3_64BIT_OFFSET_FILE "tst_pres_temp_4D_64bit_offset.nc"
#define NC3_NETCDF4_FILE "tst_pres_temp_4D_netcdf4.nc"
#define NC3_NETCDF4_CLASSIC_FILE "tst_pres_temp_4D_netcdf4_classic.nc"
printf("*** testing 4D example file in classic format...");
if (create_4D_example(NC3_CLASSIC_FILE, NC_CLOBBER)) ERR;
if (check_4D_example(NC3_CLASSIC_FILE, NC_FORMAT_CLASSIC)) ERR;
SUMMARIZE_ERR;
printf("*** testing 4D example file in 64-bit offset format...");
if (create_4D_example(NC3_64BIT_OFFSET_FILE, NC_CLOBBER|NC_64BIT_OFFSET)) ERR;
if (check_4D_example(NC3_64BIT_OFFSET_FILE, NC_FORMAT_64BIT)) ERR;
SUMMARIZE_ERR;
printf("*** testing 4D example file in netCDF-4/HDF5 format...");
if (create_4D_example(NC3_NETCDF4_FILE, NC_CLOBBER|NC_NETCDF4)) ERR;
if (check_4D_example(NC3_NETCDF4_FILE, NC_FORMAT_NETCDF4)) ERR;
SUMMARIZE_ERR;
printf("*** testing 4D example file in netCDF-4/HDF5 format with classic model rules...");
if (create_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL)) ERR;
if (check_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_FORMAT_NETCDF4_CLASSIC)) ERR;
SUMMARIZE_ERR;
FINAL_RESULTS;
#ifdef USE_PARALLEL
MPI_Finalize();
#endif
}
int
main(int argc, char **argv)
{
printf("\n*** Testing netcdf-4 string type.\n");
printf("*** testing string attribute...");
{
#define ATT_LEN_1 1
#define MOUNTAIN_RANGE "mountain_range"
size_t att_len;
int ndims, nvars, natts, unlimdimid;
nc_type att_type;
int ncid, i;
char *data_in[ATT_LEN_1] = {NULL};
char *data[ATT_LEN_1] = {"R"};
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_put_att(ncid, NC_GLOBAL, MOUNTAIN_RANGE, NC_STRING, ATT_LEN_1, data)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
if (nc_inq_att(ncid, NC_GLOBAL, MOUNTAIN_RANGE, &att_type, &att_len)) ERR;
if (att_type != NC_STRING || att_len != ATT_LEN_1) ERR;
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
if (nc_inq_att(ncid, NC_GLOBAL, MOUNTAIN_RANGE, &att_type, &att_len)) ERR;
if (att_type != NC_STRING || att_len != ATT_LEN_1) ERR;
if (nc_get_att(ncid, NC_GLOBAL, MOUNTAIN_RANGE, data_in)) ERR;
for (i = 0; i < att_len; i++)
if (strcmp(data_in[i], data[i])) ERR;
if (nc_free_string(ATT_LEN_1, (char **)data_in)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing string attribute...");
{
#define ATT_LEN 9
size_t att_len;
int ndims, nvars, natts, unlimdimid;
nc_type att_type;
int ncid, i;
char *data_in[ATT_LEN];
char *data[ATT_LEN] = {"Let but your honour know",
"Whom I believe to be most strait in virtue",
"That, in the working of your own affections",
"Had time cohered with place or place with wishing",
"Or that the resolute acting of your blood",
"Could have attain'd the effect of your own purpose",
"Whether you had not sometime in your life",
"Err'd in this point which now you censure him",
"And pull'd the law upon you."};
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_put_att(ncid, NC_GLOBAL, ATT_NAME, NC_STRING, ATT_LEN, data)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
if (nc_inq_att(ncid, NC_GLOBAL, ATT_NAME, &att_type, &att_len)) ERR;
if (att_type != NC_STRING || att_len != ATT_LEN) ERR;
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
if (nc_inq_att(ncid, NC_GLOBAL, ATT_NAME, &att_type, &att_len)) ERR;
if (att_type != NC_STRING || att_len != ATT_LEN) ERR;
if (nc_get_att(ncid, NC_GLOBAL, ATT_NAME, data_in)) ERR;
for (i = 0; i < att_len; i++)
if (strcmp(data_in[i], data[i])) ERR;
if (nc_free_string(att_len, (char **)data_in)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing string var functions...");
{
#define MOBY_LEN 16
int ncid, varid, dimids[NDIMS];
char *data[] = {"Perhaps a very little thought will now enable you to account for ",
"those repeated whaling disasters--some few of which are casually ",
"chronicled--of this man or that man being taken out of the boat by ",
"the line, and lost.",
"For, when the line is darting out, to be seated then in the boat, ",
"is like being seated in the midst of the manifold whizzings of a ",
"steam-engine in full play, when every flying beam, and shaft, and wheel, ",
"is grazing you.",
"It is worse; for you cannot sit motionless in the heart of these perils, ",
"because the boat is rocking like a cradle, and you are pitched one way and ",
"the other, without the slightest warning;",
"But why say more?",
"All men live enveloped in whale-lines.",
"All are born with halters round their necks; but it is only when caught ",
"in the swift, sudden turn of death, that mortals realize the silent, subtle, ",
"ever-present perils of life."};
char *data_in[MOBY_LEN];
int i;
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME, MOBY_LEN, dimids)) ERR;
if (nc_def_var(ncid, VAR_NAME, NC_STRING, NDIMS, dimids, &varid)) ERR;
if (nc_put_var_string(ncid, varid, (const char **)data)) ERR;
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_get_var_string(ncid, varid, data_in)) ERR;
for (i=0; i<MOBY_LEN; i++)
if (strcmp(data_in[i], data[i])) ERR;
if (nc_free_string(MOBY_LEN, (char **)data_in)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing string attributes...");
{
#define SOME_PRES 16
#define NDIMS_PRES 1
#define ATT2_NAME "presidents"
int ncid, i;
char *data[SOME_PRES] = {"Washington", "Adams", "Jefferson", "Madison",
"Monroe", "Adams", "Jackson", "Van Buren",
"Harrison", "Tyler", "Polk", "Taylor",
"Fillmore", "Pierce", "Buchanan", "Lincoln"};
char *data_in[SOME_PRES];
/* Create a file with string attribute. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_put_att_string(ncid, NC_GLOBAL, ATT2_NAME, SOME_PRES, (const char **)data)) ERR;
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_get_att_string(ncid, NC_GLOBAL, ATT2_NAME, (char **)data_in)) ERR;
for (i=0; i < SOME_PRES; i++)
if (strcmp(data_in[i], data[i])) ERR;
/* Must free your data! */
if (nc_free_string(SOME_PRES, (char **)data_in)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing string fill value...");
{
#define NUM_PRES 43
#define SOME_PRES 16
#define NDIMS_PRES 1
#define VAR_NAME_P "presidents"
int ncid, varid, i, dimids[NDIMS_PRES];
size_t start[NDIMS_PRES], count[NDIMS_PRES];
char *data[SOME_PRES] = {"Washington", "Adams", "Jefferson", "Madison",
"Monroe", "Adams", "Jackson", "Van Buren",
"Harrison", "Tyler", "Polk", "Taylor",
"Fillmore", "Pierce", "Buchanan", "Lincoln"};
char *data_in[NUM_PRES];
/* Create a file with NUM_PRES strings, and write SOME_PRES of
* them. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME, NUM_PRES, dimids)) ERR;
if (nc_def_var(ncid, VAR_NAME_P, NC_STRING, NDIMS_PRES, dimids, &varid)) ERR;
start[0] = 0;
count[0] = SOME_PRES;
if (nc_put_vara_string(ncid, varid, start, count, (const char **)data)) ERR;
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_get_var_string(ncid, varid, data_in)) ERR;
for (i = 0; i < NUM_PRES; i++)
{
if (i < SOME_PRES && (data_in[i] == NULL || strcmp(data_in[i], data[i]))) ERR;
if (i >= SOME_PRES && (data_in[i] == NULL || strcmp(data_in[i], ""))) ERR;
}
/* Must free your data! */
if (nc_free_string(NUM_PRES, (char **)data_in)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing netcdf-4 strided string access...");
{
#define NUM_PRES 43
#define SOME_PRES 16
#define NDIMS_PRES 1
#define VAR_NAME_P "presidents"
int ncid, varid, i, dimids[NDIMS_PRES];
size_t start[NDIMS_PRES], count[NDIMS_PRES];
ptrdiff_t stride[NDIMS_PRES];
char *data[SOME_PRES] = {"Washington", "Adams", "Jefferson", "Madison",
"Monroe", "Adams", "Jackson", "Van Buren",
"Harrison", "Tyler", "Polk", "Taylor",
"Fillmore", "Pierce", "Buchanan", "Lincoln"};
char *data_in[NUM_PRES];
int status;
/* Create a file with NUM_PRES strings, and write SOME_PRES of
* them. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME, NUM_PRES, dimids)) ERR;
if (nc_def_var(ncid, VAR_NAME_P, NC_STRING, NDIMS_PRES, dimids, &varid)) ERR;
start[0] = 0;
count[0] = SOME_PRES;
stride[0] = 2;
status = nc_put_vars_string(ncid, varid, start, count, stride, (const char **)data);
if(status != NC_NOERR)
fprintf(stderr,"%s\n",nc_strerror(status));
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_get_vars_string(ncid, varid, start, count, stride, data_in)) ERR;
for (i = 0; i < NUM_PRES; i++)
{
if (i < SOME_PRES && strcmp(data_in[i], data[i])) ERR;
}
/* Must free your data! */
if (nc_free_string(SOME_PRES, (char **)data_in)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing string variables with fill values...");
{
#define VAR_NAME2 "empty"
#define ATT_NAME2 "empty"
#define DHR_LEN 30
#define DIM_NAME1 "article"
#define VAR_NAME1 "universal_declaration_of_human_rights"
int var_dimids[NDIMS];
int ndims, nvars, natts, unlimdimid;
nc_type var_type;
char var_name[NC_MAX_NAME + 1];
int var_natts, var_ndims;
int ncid, varid, i, dimids[NDIMS], varid2;
char *data[DHR_LEN] = {
"All human beings are born free and equal in dignity and rights. "
"They are endowed with reason and "
"conscience and should act towards one another in a "
"spirit of brotherhood.",
"Everyone is entitled to all the rights and freedoms set "
"forth in this Declaration, without distinction of "
"any kind, such as race, colour, sex, language, religion, "
"political or other opinion, national or social "
"origin, property, birth or other status. Furthermore, no "
"distinction shall be made on the basis of the "
"political, jurisdictional or international status of the "
"country or territory to which a person belongs, "
"whether it be independent, trust, non-self-governing or "
"under any other limitation of sovereignty.",
"Everyone has the right to life, liberty and security of person.",
"No one shall be held in slavery or servitude; slavery and the "
"slave trade shall be prohibited in all their forms.",
"No one shall be subjected to torture or to cruel, "
"inhuman or degrading treatment or punishment.",
"Everyone has the right to recognition everywhere as "
"a person before the law.",
"All are equal before the law and are entitled without "
"any discrimination to equal protection of the law. All are "
"entitled to equal protection against any discrimination in "
"violation of this Declaration and against any incitement "
"to such discrimination.",
"Everyone has the right to an effective remedy by the "
"competent national tribunals for acts violating the "
"fundamental rights granted "
"him by the constitution or by law.",
"No one shall be subjected to arbitrary arrest, detention or exile.",
"Everyone is entitled in full equality to a fair and public "
"hearing by an independent and impartial tribunal, in the "
"determination of his rights and obligations and of any "
"criminal charge against him.",
"(1) Everyone charged with a penal offence has the right "
"to be presumed innocent until proved guilty according to law in a "
"public trial at which he has had all the guarantees "
"necessary for his defence."
"(2) No one shall be held guilty of any penal offence "
"on account of any act or omission which did not constitute a penal "
"offence, under national or international law, at the time "
"when it was committed. Nor shall a heavier penalty be imposed "
"than the one that was applicable at the time the penal "
"offence was committed.",
"No one shall be subjected to arbitrary interference with "
"his privacy, family, home or correspondence, nor to attacks upon "
"his honour and reputation. Everyone has the right to the "
"protection of the law against such interference or attacks.",
"(1) Everyone has the right to freedom of movement and "
"residence within the borders of each state."
"(2) Everyone has the right to leave any country, "
"including his own, and to return to his country.",
"(1) Everyone has the right to seek and to enjoy in "
"other countries asylum from persecution. "
"(2) This right may not be invoked in the case of prosecutions "
"genuinely arising from non-political crimes or from acts "
"contrary to the purposes and principles of the United Nations.",
"(1) Everyone has the right to a nationality. (2) No one shall "
"be arbitrarily deprived of his nationality nor denied the "
"right to change his nationality.",
"(1) Men and women of full age, without any limitation "
"due to race, nationality or religion, have the right "
"to marry and to found a family. "
"They are entitled to equal rights as to marriage, "
"during marriage and at its dissolution. (2) Marriage "
"shall be entered into only with the free and full "
"consent of the intending spouses. (3) The family is "
"the natural and fundamental group unit of society and "
"is entitled to protection by society and the State.",
"(1) Everyone has the right to own property alone as "
"well as in association with others. (2) No one shall "
"be arbitrarily deprived of his property.",
"Everyone has the right to freedom of thought, conscience "
"and religion; this right includes freedom to change "
"his religion or belief, and freedom, "
"either alone or in community with others and in "
"public or private, to manifest his religion or "
"belief in teaching, practice, worship and observance.",
"Everyone has the right to freedom of opinion and "
"expression; this right includes freedom to hold "
"opinions without interference and to seek, receive "
"and impart information and ideas through any media "
"and regardless of frontiers.",
"(1) Everyone has the right to freedom of peaceful assembly "
"and association. (2) No one may be compelled to belong to "
"an association.",
"(1) Everyone has the right to take part in the government "
"of his country, directly or through freely chosen representatives. "
"(2) Everyone has the right of equal access to public "
"service in his country. (3) The will of the people "
"shall be the basis of the authority of government; "
"this will shall be expressed in periodic and genuine "
"elections which shall be by universal and equal suffrage "
"and shall be held by secret vote or by "
"equivalent free voting procedures.",
"Everyone, as a member of society, has the right to "
"social security and is entitled to realization, "
"through national effort and international co-operation "
"and in accordance with the organization and resources of "
"each State, of the economic, social and cultural rights "
"indispensable for his dignity and the free "
"development of his personality.",
"(1) Everyone has the right to work, to free choice "
"of employment, to just and favourable conditions of "
"work and to protection against unemployment. "
"(2) Everyone, without any discrimination, has the right "
"to equal pay for equal work. (3) Everyone who works "
"has the right to just and favourable "
"remuneration ensuring for himself and his family an "
"existence worthy of human dignity, and supplemented, "
"if necessary, by other means of social protection."
"(4) Everyone has the right to form and to join trade "
"unions for the protection of his interests.",
"Everyone has the right to rest and leisure, including "
"reasonable limitation of working hours and periodic "
"holidays with pay.",
"(1) Everyone has the right to a standard of living "
"adequate for the health and well-being of himself "
"and of his family, including food, clothing, housing "
"and medical care and necessary social services, and "
"the right to security in the event of unemployment, "
"sickness, disability, widowhood, old age or other lack "
"of livelihood in circumstances beyond his control. "
"(2) Motherhood and childhood are entitled to special "
"care and assistance. All children, whether "
"born in or out of wedlock, shall enjoy the same "
"social protection.",
"(1) Everyone has the right to education. Education "
"shall be free, at least in the elementary and "
"fundamental stages. Elementary education shall be compulsory. "
"Technical and professional education shall be made generally "
"available and higher education "
"shall be equally accessible to all on the basis of merit. "
"(2) Education shall be directed to the full development of "
"the human personality and to the strengthening of respect for "
"human rights and fundamental freedoms. "
"It shall promote understanding, tolerance and friendship among "
"all nations, racial or religious groups, and shall further the "
"activities of the United Nations "
"for the maintenance of peace. (3) Parents have a prior right to "
"choose the kind of education that shall be given to their children.",
"(1) Everyone has the right freely to participate in the cultural "
"life of the community, to enjoy the arts and to share in scientific "
"advancement and its benefits. "
"(2) Everyone has the right to the protection of the moral "
"and material interests resulting from any scientific, "
"literary or artistic production of which he is the author.",
"Everyone is entitled to a social and international order in "
"which the rights and freedoms set forth in this Declaration "
"can be fully realized.",
"(1) Everyone has duties to the community in which alone "
"the free and full development of his personality is possible. "
"(2) In the exercise of his rights and "
"freedoms, everyone shall be subject only to such limitations "
"as are determined by law solely for the purpose "
"of securing due recognition and respect for the rights "
"and freedoms of others and of meeting the just requirements "
"of morality, public order and the general welfare in a "
"democratic society. (3) These rights and freedoms may in no "
"case be exercised contrary to the purposes and "
"principles of the United Nations.",
"Nothing in this Declaration may be interpreted as implying "
"for any State, group or person any right to engage in any "
"activity or to perform any act aimed at the destruction of "
"any of the rights and freedoms set forth herein."
};
char *empty_string[] = {""};
char *my_string_fill[] = {"fill_string"};
#define NUM_DIM_COMBOS 4
int dim_combo;
for (dim_combo = 0; dim_combo < NUM_DIM_COMBOS; dim_combo++)
{
char filename[NC_MAX_NAME + 1];
int dim_len = dim_combo ? NC_UNLIMITED : DHR_LEN;
int expected_unlimdimid = dim_combo ? 0 : -1;
char *default_fill = ((char *)"");
char **string_fillp = dim_combo == 3 ? my_string_fill : &default_fill;
char *data_in;
sprintf(filename, "%s_dim_combo_%d.nc", TEST_NAME, dim_combo);
if (nc_create(filename, NC_NETCDF4, &ncid)) ERR;
/* Create an array of strings for the Universal Declaraion of Human Rights. */
if (nc_def_dim(ncid, DIM_NAME1, dim_len, dimids)) ERR;
if (nc_def_var(ncid, VAR_NAME1, NC_STRING, NDIMS, dimids, &varid)) ERR;
/* Create a scalar variable for the empty string. */
if (nc_def_var(ncid, VAR_NAME2, NC_STRING, 0, NULL, &varid2)) ERR;
if (dim_combo == 3)
if (nc_put_att(ncid, varid, _FillValue, NC_STRING, 1, my_string_fill)) ERR;
/* Check some stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS || nvars != 2 || natts != 0 || unlimdimid != expected_unlimdimid) ERR;
if (nc_inq_var(ncid, varid, var_name, &var_type, &var_ndims,
var_dimids, &var_natts)) ERR;
if (var_type != NC_STRING || strcmp(var_name, VAR_NAME1) || var_ndims != NDIMS ||
var_dimids[0] != dimids[0]) ERR;
/* Write the universal declaraion of human rights. */
if (dim_combo)
{
size_t start[NDIMS], count[NDIMS] = {1};
int counter = 1;
/* Write one record at a time. */
for (start[0] = 0; start[0] < DHR_LEN; start[0]++)
{
size_t new_start[NDIMS];
size_t *my_startp = start;
/* For dim_combo 2 or 3 skip every other record. */
new_start[0] = start[0] + counter++;
if (dim_combo >= 2)
my_startp = new_start;
/* Write a record. */
nc_put_vara_string(ncid, varid, my_startp, count, (const char **)&data[start[0]]);
}
}
else
{
/* Write all records at once. */
if (nc_put_var(ncid, varid, data)) ERR;
}
/* Write an empty string with an empty attribute. */
if (nc_put_var(ncid, varid2, empty_string)) ERR;
if (nc_put_att(ncid, varid2, ATT_NAME2, NC_STRING, 0, empty_string)) ERR;
/* Close the file. */
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(filename, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS || nvars != 2 || natts != 0 || unlimdimid != expected_unlimdimid) ERR;
/* Check declaration. */
if (nc_inq_varid(ncid, VAR_NAME1, &varid)) ERR;
if (nc_inq_var(ncid, varid, var_name, &var_type, &var_ndims, var_dimids,
&var_natts)) ERR;
if (var_type != NC_STRING || strcmp(var_name, VAR_NAME1) || var_ndims != NDIMS ||
var_dimids[0] != dimids[0]) ERR;
/* Check fill value stuff. */
{
int no_fill;
char *fill_value_in[1];
if (nc_inq_var_fill(ncid, varid, &no_fill, (char **)fill_value_in)) ERR;
if (no_fill) ERR;
if (strcmp(fill_value_in[0], *string_fillp)) ERR;
if (nc_free_string(1, (char **)fill_value_in)) ERR;
}
if (dim_combo < 2)
{
char *data_in[DHR_LEN];
/* Get the data in one read of the entire var. */
if (nc_get_var(ncid, varid, data_in)) ERR;
for (i = 0; i < DHR_LEN; i++)
if (strcmp(data_in[i], data[i])) ERR;
if (nc_free_string(DHR_LEN, data_in)) ERR;
}
else
{
char *data_in;
size_t start[NDIMS], count[NDIMS] = {1};
int my_count = 0;
/* Get the data one record at a time. Every other record,
* starting with the first, is a fill value. */
for (start[0] = 0; start[0] < DHR_LEN; start[0]++)
{
if (nc_get_vara(ncid, varid, start, count, &data_in)) ERR;
if (start[0] % 2)
{
if (strcmp(data_in, data[my_count++])) ERR;
}
else
{
if (strcmp(data_in, *string_fillp)) ERR;
}
if (nc_free_string(1, &data_in)) ERR;
}
}
/* Check the empty var and att. */
if (nc_inq_varid(ncid, VAR_NAME2, &varid)) ERR;
if (nc_get_var(ncid, varid, &data_in)) ERR;
if (strcmp(data_in, empty_string[0])) ERR;
if (nc_free_string(1, &data_in)) ERR;
if (nc_get_att(ncid, varid, ATT_NAME2, NULL)) ERR;
if (nc_close(ncid)) ERR;
} /* next dim_combo */
}
SUMMARIZE_ERR;
printf("*** Testing a file that causes ncdump problems...");
{
#define NUM_DIMS 2
#define DIM_0_NAME "dim_0"
#define DIM_1_NAME "dim_1"
#define DIM_1_LEN 2
#define FILE_NAME_NCDUMP "tst_strings_ncdump_problem.nc"
#define VAR_NAME_NCDUMP "var_string"
int ncid, varid, dimid[NUM_DIMS];
char *string_data[] = {"x"};
int t;
/* Create a file. */
if (nc_create(FILE_NAME_NCDUMP, NC_NETCDF4, &ncid)) ERR;
/* Create dims. */
if (nc_def_dim(ncid, DIM_0_NAME, NC_UNLIMITED, &dimid[0])) ERR;
if (nc_def_dim(ncid, DIM_1_NAME, DIM_1_LEN, &dimid[1])) ERR;
/* Create a var. */
if (nc_def_var(ncid, VAR_NAME_NCDUMP, NC_STRING, NUM_DIMS, dimid, &varid)) ERR;
/* Check that you can't turn off fill mode for NC_STRING variables. */
if (nc_def_var_fill(ncid, varid, NC_NOFILL, NULL) != NC_EINVAL) ERR;
/* End define mode. */
if (nc_enddef(ncid)) ERR;
/* Write to each var. */
for (t = 0; t < 1; t++)
{
size_t start[NUM_DIMS] = {1, 0};
size_t count[NUM_DIMS] = {1, 1};
if (nc_put_vara_string(ncid, varid, start, count, (const char **)string_data)) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
