mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2024-12-21 08:39:46 +08:00
Code Issues Packages Projects Releases Wiki Activity
f844126d0e
netcdf-c/nc_test/test_put.m4

1144 lines
31 KiB
Plaintext
Raw Blame History

dnl This is m4 source.
dnl Process using m4 to produce 'C' language file.
dnl
dnl If you see this line, you can ignore the next one.
/* Do not edit this file. It is produced from the corresponding .m4 source */
dnl
/*********************************************************************
* Copyright 1996, UCAR/Unidata
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
* $Id: test_put.m4,v 1.25 2005/03/08 03:04:19 ed Exp $
*********************************************************************/
undefine(`index')dnl
dnl dnl dnl
dnl
dnl Macros
dnl
dnl dnl dnl
dnl
dnl Upcase(str)
dnl
define(`Upcase',dnl
`dnl
translit($1, abcdefghijklmnopqrstuvwxyz, ABCDEFGHIJKLMNOPQRSTUVWXYZ)')dnl
dnl dnl dnl
dnl
dnl NCT_ITYPE(type)
dnl
define(`NCT_ITYPE', ``NCT_'Upcase($1)')dnl
dnl
#include "tests.h"
dnl HASH(TYPE)
dnl
define(`HASH',dnl
`dnl
/*
* ensure hash value within range for internal TYPE
*/
static
double
hash_$1(
const nc_type type,
const int rank,
const size_t *index,
const nct_itype itype)
{
const double min = $1_min;
const double max = $1_max;
return MAX(min, MIN(max, hash4( type, rank, index, itype)));
}
')dnl
HASH(text)
HASH(uchar)
HASH(schar)
HASH(short)
HASH(int)
HASH(long)
HASH(float)
HASH(double)
dnl CHECK_VARS(TYPE)
dnl
define(`CHECK_VARS',dnl
`dnl
/*
* check all vars in file which are (text/numeric) compatible with TYPE
*/
static
void
check_vars_$1(const char *filename)
{
int ncid; /* netCDF id */
size_t index[MAX_RANK];
int err; /* status */
int d;
int i;
size_t j;
$1 value;
nc_type datatype;
int ndims;
int dimids[MAX_RANK];
double expect;
char name[NC_MAX_NAME];
size_t length;
int canConvert; /* Both text or both numeric */
int nok = 0; /* count of valid comparisons */
err = nc_open(filename, NC_NOWRITE, &ncid);
IF (err)
error("nc_open: %s", nc_strerror(err));
for (i = 0; i < NVARS; i++) {
canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
if (canConvert) {
err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);
IF (err)
error("nc_inq_var: %s", nc_strerror(err));
IF (strcmp(name, var_name[i]) != 0)
error("Unexpected var_name");
IF (datatype != var_type[i])
error("Unexpected type");
IF (ndims != var_rank[i])
error("Unexpected rank");
for (j = 0; j < ndims; j++) {
err = nc_inq_dim(ncid, dimids[j], 0, &length);
IF (err)
error("nc_inq_dim: %s", nc_strerror(err));
IF (length != var_shape[i][j])
error("Unexpected shape");
}
for (j = 0; j < var_nels[i]; j++) {
err = toMixedBase(j, var_rank[i], var_shape[i], index);
IF (err)
error("error in toMixedBase 2");
expect = hash4( var_type[i], var_rank[i], index, NCT_ITYPE($1));
err = nc_get_var1_$1(ncid, i, index, &value);
if (inRange3(expect,datatype,NCT_ITYPE($1))) {
if (expect >= $1_min && expect <= $1_max) {
IF (err) {
error("nc_get_var1_$1: %s", nc_strerror(err));
} else {
IF (!equal(value,expect,var_type[i],NCT_ITYPE($1))) {
error("Var value read not that expected");
if (verbose) {
error("\n");
error("varid: %d, ", i);
error("var_name: %s, ", var_name[i]);
error("index:");
for (d = 0; d < var_rank[i]; d++)
error(" %d", index[d]);
error(", expect: %g, ", expect);
error("got: %g", (double) value);
}
} else {
++nok;
}
}
}
}
}
}
}
err = nc_close (ncid);
IF (err)
error("nc_close: %s", nc_strerror(err));
print_nok(nok);
}
')dnl
CHECK_VARS(text)
CHECK_VARS(uchar)
CHECK_VARS(schar)
CHECK_VARS(short)
CHECK_VARS(int)
CHECK_VARS(long)
CHECK_VARS(float)
CHECK_VARS(double)
dnl CHECK_ATTS(TYPE) numeric only
dnl
define(`CHECK_ATTS',dnl
`dnl
/*
* check all attributes in file which are (text/numeric) compatible with TYPE
* ignore any attributes containing values outside range of TYPE
*/
static
void
check_atts_$1(int ncid)
{
int err; /* status */
int i;
int j;
size_t k;
$1 value[MAX_NELS];
nc_type datatype;
double expect[MAX_NELS];
size_t length;
size_t nInExtRange; /* number values within external range */
size_t nInIntRange; /* number values within internal range */
int canConvert; /* Both text or both numeric */
int nok = 0; /* count of valid comparisons */
for (i = -1; i < NVARS; i++) {
for (j = 0; j < NATTS(i); j++) {
canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
if (canConvert) {
err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);
IF (err)
error("nc_inq_att: %s", nc_strerror(err));
IF (datatype != ATT_TYPE(i,j))
error("nc_inq_att: unexpected type");
IF (length != ATT_LEN(i,j))
error("nc_inq_att: unexpected length");
assert(length <= MAX_NELS);
nInIntRange = nInExtRange = 0;
for (k = 0; k < length; k++) {
expect[k] = hash4( datatype, -1, &k, NCT_ITYPE($1));
if (inRange3(expect[k], datatype, NCT_ITYPE($1))) {
++nInExtRange;
if (expect[k] >= $1_min && expect[k] <= $1_max)
++nInIntRange;
}
}
err = nc_get_att_$1(ncid, i, ATT_NAME(i,j), value);
if (nInExtRange == length && nInIntRange == length) {
IF (err)
error("%s", nc_strerror(err));
} else {
IF (err != 0 && err != NC_ERANGE)
error("OK or Range error: status = %d", err);
}
for (k = 0; k < length; k++) {
if (inRange3(expect[k],datatype,NCT_ITYPE($1))
&& expect[k] >= $1_min && expect[k] <= $1_max) {
IF (!equal(value[k],expect[k],datatype,NCT_ITYPE($1))) {
error("att. value read not that expected");
if (verbose) {
error("\n");
error("varid: %d, ", i);
error("att_name: %s, ", ATT_NAME(i,j));
error("element number: %d ", k);
error("expect: %g, ", expect[k]);
error("got: %g", (double) value[k]);
}
} else {
nok++;
}
}
}
}
}
}
print_nok(nok);
}
')dnl
CHECK_ATTS(text)
CHECK_ATTS(uchar)
CHECK_ATTS(schar)
CHECK_ATTS(short)
CHECK_ATTS(int)
CHECK_ATTS(long)
CHECK_ATTS(float)
CHECK_ATTS(double)
dnl TEST_NC_PUT_VAR1(TYPE)
dnl
define(`TEST_NC_PUT_VAR1',dnl
`dnl
void
test_nc_put_var1_$1(void)
{
int ncid;
int i;
int j;
int err;
size_t index[MAX_RANK];
int canConvert; /* Both text or both numeric */
$1 value = 5; /* any value would do - only for error cases */
err = nc_create(scratch, NC_CLOBBER, &ncid);
IF (err) {
error("nc_create: %s", nc_strerror(err));
return;
}
def_dims(ncid);
def_vars(ncid);
err = nc_enddef(ncid);
IF (err)
error("nc_enddef: %s", nc_strerror(err));
for (i = 0; i < NVARS; i++) {
canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
for (j = 0; j < var_rank[i]; j++)
index[j] = 0;
err = nc_put_var1_$1(BAD_ID, i, index, &value);
IF (err != NC_EBADID)
error("bad ncid: status = %d", err);
err = nc_put_var1_$1(ncid, BAD_VARID, index, &value);
IF (err != NC_ENOTVAR)
error("bad var id: status = %d", err);
for (j = 0; j < var_rank[i]; j++) {
if (var_dimid[i][j] > 0) { /* skip record dim */
index[j] = var_shape[i][j];
err = nc_put_var1_$1(ncid, i, index, &value);
IF (canConvert && err != NC_EINVALCOORDS)
error("bad index: status = %d", err);
index[j] = 0;
}
}
for (j = 0; j < var_nels[i]; j++) {
err = toMixedBase(j, var_rank[i], var_shape[i], index);
IF (err)
error("error in toMixedBase 1");
value = hash_$1( var_type[i], var_rank[i], index, NCT_ITYPE($1));
if (var_rank[i] == 0 && i%2 == 0)
err = nc_put_var1_$1(ncid, i, NULL, &value);
else
err = nc_put_var1_$1(ncid, i, index, &value);
if (canConvert) {
if (inRange3(value, var_type[i],NCT_ITYPE($1))) {
IF (err)
error("%s", nc_strerror(err));
} else {
IF (err != NC_ERANGE) {
error("Range error: status = %d", err);
error("\n\t\tfor type %s value %.17e %ld",
s_nc_type(var_type[i]),
(double)value, (long)value);
}
}
} else {
IF (err != NC_ECHAR)
error("wrong type: status = %d", err);
}
}
}
err = nc_close(ncid);
IF (err)
error("nc_close: %s", nc_strerror(err));
check_vars_$1(scratch);
err = remove(scratch);
IF (err)
error("remove of %s failed", scratch);
}
')dnl
TEST_NC_PUT_VAR1(text)
TEST_NC_PUT_VAR1(uchar)
TEST_NC_PUT_VAR1(schar)
TEST_NC_PUT_VAR1(short)
TEST_NC_PUT_VAR1(int)
TEST_NC_PUT_VAR1(long)
TEST_NC_PUT_VAR1(float)
TEST_NC_PUT_VAR1(double)
dnl TEST_NC_PUT_VAR(TYPE)
dnl
define(`TEST_NC_PUT_VAR',dnl
`dnl
void
test_nc_put_var_$1(void)
{
int ncid;
int varid;
int i;
int j;
int err;
int nels;
size_t index[MAX_RANK];
int canConvert; /* Both text or both numeric */
int allInExtRange; /* all values within external range? */
$1 value[MAX_NELS];
err = nc_create(scratch, NC_CLOBBER, &ncid);
IF (err) {
error("nc_create: %s", nc_strerror(err));
return;
}
def_dims(ncid);
def_vars(ncid);
err = nc_enddef(ncid);
IF (err)
error("nc_enddef: %s", nc_strerror(err));
for (i = 0; i < NVARS; i++) {
canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
assert(var_rank[i] <= MAX_RANK);
assert(var_nels[i] <= MAX_NELS);
err = nc_put_var_$1(BAD_ID, i, value);
IF (err != NC_EBADID)
error("bad ncid: status = %d", err);
err = nc_put_var_$1(ncid, BAD_VARID, value);
IF (err != NC_ENOTVAR)
error("bad var id: status = %d", err);
nels = 1;
for (j = 0; j < var_rank[i]; j++) {
nels *= var_shape[i][j];
}
for (allInExtRange = 1, j = 0; j < nels; j++) {
err = toMixedBase(j, var_rank[i], var_shape[i], index);
IF (err)
error("error in toMixedBase 1");
value[j]= hash_$1(var_type[i], var_rank[i], index, NCT_ITYPE($1));
allInExtRange = allInExtRange
&& inRange3(value[j], var_type[i], NCT_ITYPE($1));
}
err = nc_put_var_$1(ncid, i, value);
if (canConvert) {
if (allInExtRange) {
IF (err)
error("%s", nc_strerror(err));
} else {
IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
error("range error: status = %d", err);
}
} else { /* should flag wrong type even if nothing to write */
IF (nels > 0 && err != NC_ECHAR)
error("wrong type: status = %d", err);
}
}
/* Preceeding has written nothing for record variables, now try */
/* again with more than 0 records */
/* Write record number NRECS to force writing of preceding records */
/* Assumes variable cr is char vector with UNLIMITED dimension */
err = nc_inq_varid(ncid, "cr", &varid);
IF (err)
error("nc_inq_varid: %s", nc_strerror(err));
index[0] = NRECS-1;
err = nc_put_var1_text(ncid, varid, index, "x");
IF (err)
error("nc_put_var1_text: %s", nc_strerror(err));
for (i = 0; i < NVARS; i++) {
if (var_dimid[i][0] == RECDIM) { /* only test record variables here */
canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
assert(var_rank[i] <= MAX_RANK);
assert(var_nels[i] <= MAX_NELS);
err = nc_put_var_$1(BAD_ID, i, value);
IF (err != NC_EBADID)
error("bad ncid: status = %d", err);
nels = 1;
for (j = 0; j < var_rank[i]; j++) {
nels *= var_shape[i][j];
}
for (allInExtRange = 1, j = 0; j < nels; j++) {
err = toMixedBase(j, var_rank[i], var_shape[i], index);
IF (err)
error("error in toMixedBase 1");
value[j]= hash_$1(var_type[i], var_rank[i], index, NCT_ITYPE($1));
allInExtRange = allInExtRange
&& inRange3(value[j], var_type[i], NCT_ITYPE($1));
}
err = nc_put_var_$1(ncid, i, value);
if (canConvert) {
if (allInExtRange) {
IF (err)
error("%s", nc_strerror(err));
} else {
IF (err != NC_ERANGE)
error("range error: status = %d", err);
}
} else {
IF (nels > 0 && err != NC_ECHAR)
error("wrong type: status = %d", err);
}
}
}
err = nc_close(ncid);
IF (err)
error("nc_close: %s", nc_strerror(err));
check_vars_$1(scratch);
err = remove(scratch);
IF (err)
error("remove of %s failed", scratch);
}
')dnl
TEST_NC_PUT_VAR(text)
TEST_NC_PUT_VAR(uchar)
TEST_NC_PUT_VAR(schar)
TEST_NC_PUT_VAR(short)
TEST_NC_PUT_VAR(int)
TEST_NC_PUT_VAR(long)
TEST_NC_PUT_VAR(float)
TEST_NC_PUT_VAR(double)
dnl TEST_NC_PUT_VARA(TYPE)
dnl
define(`TEST_NC_PUT_VARA',dnl
`dnl
void
test_nc_put_vara_$1(void)
{
int ncid;
int d;
int i;
int j;
int k;
int err;
int nslabs;
int nels;
size_t start[MAX_RANK];
size_t edge[MAX_RANK];
size_t mid[MAX_RANK];
size_t index[MAX_RANK];
int canConvert; /* Both text or both numeric */
int allInExtRange; /* all values within external range? */
$1 value[MAX_NELS];
err = nc_create(scratch, NC_CLOBBER, &ncid);
IF (err) {
error("nc_create: %s", nc_strerror(err));
return;
}
def_dims(ncid);
def_vars(ncid);
err = nc_enddef(ncid);
IF (err)
error("nc_enddef: %s", nc_strerror(err));
value[0] = 0;
for (i = 0; i < NVARS; i++) {
canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
assert(var_rank[i] <= MAX_RANK);
assert(var_nels[i] <= MAX_NELS);
for (j = 0; j < var_rank[i]; j++) {
start[j] = 0;
edge[j] = 1;
}
err = nc_put_vara_$1(BAD_ID, i, start, edge, value);
IF (err != NC_EBADID)
error("bad ncid: status = %d", err);
err = nc_put_vara_$1(ncid, BAD_VARID, start, edge, value);
IF (err != NC_ENOTVAR)
error("bad var id: status = %d", err);
for (j = 0; j < var_rank[i]; j++) {
if (var_dimid[i][j] > 0) { /* skip record dim */
start[j] = var_shape[i][j];
err = nc_put_vara_$1(ncid, i, start, edge, value);
IF (canConvert && err != NC_EINVALCOORDS)
error("bad start: status = %d", err);
start[j] = 0;
edge[j] = var_shape[i][j] + 1;
err = nc_put_vara_$1(ncid, i, start, edge, value);
IF (canConvert && err != NC_EEDGE)
error("bad edge: status = %d", err);
edge[j] = 1;
}
}
/* Check correct error returned even when nothing to put */
for (j = 0; j < var_rank[i]; j++) {
edge[j] = 0;
}
err = nc_put_vara_$1(BAD_ID, i, start, edge, value);
IF (err != NC_EBADID)
error("bad ncid: status = %d", err);
err = nc_put_vara_$1(ncid, BAD_VARID, start, edge, value);
IF (err != NC_ENOTVAR)
error("bad var id: status = %d", err);
for (j = 0; j < var_rank[i]; j++) {
if (var_dimid[i][j] > 0) { /* skip record dim */
start[j] = var_shape[i][j];
err = nc_put_vara_$1(ncid, i, start, edge, value);
IF (canConvert && err != NC_EINVALCOORDS)
error("bad start: status = %d", err);
start[j] = 0;
}
}
err = nc_put_vara_$1(ncid, i, start, edge, value);
if (canConvert) {
IF (err)
error("%s", nc_strerror(err));
} else {
IF (err != NC_ECHAR)
error("wrong type: status = %d", err);
}
for (j = 0; j < var_rank[i]; j++) {
edge[j] = 1;
}
/* Choose a random point dividing each dim into 2 parts */
/* Put 2^rank (nslabs) slabs so defined */
nslabs = 1;
for (j = 0; j < var_rank[i]; j++) {
mid[j] = roll( var_shape[i][j] );
nslabs *= 2;
}
/* bits of k determine whether to put lower or upper part of dim */
for (k = 0; k < nslabs; k++) {
nels = 1;
for (j = 0; j < var_rank[i]; j++) {
if ((k >> j) & 1) {
start[j] = 0;
edge[j] = mid[j];
}else{
start[j] = mid[j];
edge[j] = var_shape[i][j] - mid[j];
}
nels *= edge[j];
}
for (allInExtRange = 1, j = 0; j < nels; j++) {
err = toMixedBase(j, var_rank[i], edge, index);
IF (err)
error("error in toMixedBase 1");
for (d = 0; d < var_rank[i]; d++)
index[d] += start[d];
value[j]= hash_$1(var_type[i], var_rank[i], index, NCT_ITYPE($1));
allInExtRange = allInExtRange
&& inRange3(value[j], var_type[i], NCT_ITYPE($1));
}
if (var_rank[i] == 0 && i%2 == 0)
err = nc_put_vara_$1(ncid, i, NULL, NULL, value);
else
err = nc_put_vara_$1(ncid, i, start, edge, value);
if (canConvert) {
if (allInExtRange) {
IF (err)
error("%s", nc_strerror(err));
} else {
IF (err != NC_ERANGE)
error("range error: status = %d", err);
}
} else {
IF (nels > 0 && err != NC_ECHAR)
error("wrong type: status = %d", err);
}
}
}
err = nc_close(ncid);
IF (err)
error("nc_close: %s", nc_strerror(err));
check_vars_$1(scratch);
err = remove(scratch);
IF (err)
error("remove of %s failed", scratch);
}
')dnl
TEST_NC_PUT_VARA(text)
TEST_NC_PUT_VARA(uchar)
TEST_NC_PUT_VARA(schar)
TEST_NC_PUT_VARA(short)
TEST_NC_PUT_VARA(int)
TEST_NC_PUT_VARA(long)
TEST_NC_PUT_VARA(float)
TEST_NC_PUT_VARA(double)
dnl TEST_NC_PUT_VARS(TYPE)
dnl
define(`TEST_NC_PUT_VARS',dnl
`dnl
void
test_nc_put_vars_$1(void)
{
int ncid;
int d;
int i;
int j;
int k;
int m;
int err;
int nels;
int nslabs;
int nstarts; /* number of different starts */
size_t start[MAX_RANK];
size_t edge[MAX_RANK];
size_t index[MAX_RANK];
size_t index2[MAX_RANK];
size_t mid[MAX_RANK];
size_t count[MAX_RANK];
size_t sstride[MAX_RANK];
ptrdiff_t stride[MAX_RANK];
int canConvert; /* Both text or both numeric */
int allInExtRange; /* all values within external range? */
$1 value[MAX_NELS];
err = nc_create(scratch, NC_CLOBBER, &ncid);
IF (err) {
error("nc_create: %s", nc_strerror(err));
return;
}
def_dims(ncid);
def_vars(ncid);
err = nc_enddef(ncid);
IF (err)
error("nc_enddef: %s", nc_strerror(err));
for (i = 0; i < NVARS; i++) {
canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
assert(var_rank[i] <= MAX_RANK);
assert(var_nels[i] <= MAX_NELS);
for (j = 0; j < var_rank[i]; j++) {
start[j] = 0;
edge[j] = 1;
stride[j] = 1;
}
err = nc_put_vars_$1(BAD_ID, i, start, edge, stride, value);
IF (err != NC_EBADID)
error("bad ncid: status = %d", err);
err = nc_put_vars_$1(ncid, BAD_VARID, start, edge, stride, value);
IF (err != NC_ENOTVAR)
error("bad var id: status = %d", err);
for (j = 0; j < var_rank[i]; j++) {
if (var_dimid[i][j] > 0) { /* skip record dim */
start[j] = var_shape[i][j] + 1;
err = nc_put_vars_$1(ncid, i, start, edge, stride, value);
if(!canConvert) {
IF(err != NC_ECHAR)
error("conversion: status = %d", err);
} else {
IF(err != NC_EINVALCOORDS)
error("bad start: status = %d", err);
start[j] = 0;
edge[j] = var_shape[i][j] + 1;
err = nc_put_vars_$1(ncid, i, start, edge, stride, value);
IF (err != NC_EEDGE)
error("bad edge: status = %d", err);
edge[j] = 1;
stride[j] = 0;
err = nc_put_vars_$1(ncid, i, start, edge, stride, value);
IF (err != NC_ESTRIDE)
error("bad stride: status = %d", err);
stride[j] = 1;
}
}
}
/* Choose a random point dividing each dim into 2 parts */
/* Put 2^rank (nslabs) slabs so defined */
nslabs = 1;
for (j = 0; j < var_rank[i]; j++) {
mid[j] = roll( var_shape[i][j] );
nslabs *= 2;
}
/* bits of k determine whether to put lower or upper part of dim */
/* choose random stride from 1 to edge */
for (k = 0; k < nslabs; k++) {
nstarts = 1;
for (j = 0; j < var_rank[i]; j++) {
if ((k >> j) & 1) {
start[j] = 0;
edge[j] = mid[j];
}else{
start[j] = mid[j];
edge[j] = var_shape[i][j] - mid[j];
}
sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
nstarts *= stride[j];
}
for (m = 0; m < nstarts; m++) {
err = toMixedBase(m, var_rank[i], sstride, index);
IF (err)
error("error in toMixedBase");
nels = 1;
for (j = 0; j < var_rank[i]; j++) {
count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
nels *= count[j];
index[j] += start[j];
}
/* Random choice of forward or backward */
/* TODO
if ( roll(2) ) {
for (j = 0; j < var_rank[i]; j++) {
index[j] += (count[j] - 1) * stride[j];
stride[j] = -stride[j];
}
}
*/
for (allInExtRange = 1, j = 0; j < nels; j++) {
err = toMixedBase(j, var_rank[i], count, index2);
IF (err)
error("error in toMixedBase");
for (d = 0; d < var_rank[i]; d++)
index2[d] = index[d] + index2[d] * stride[d];
value[j] = hash_$1(var_type[i], var_rank[i], index2,
NCT_ITYPE($1));
allInExtRange = allInExtRange
&& inRange3(value[j], var_type[i], NCT_ITYPE($1));
}
if (var_rank[i] == 0 && i%2 == 0)
err = nc_put_vars_$1(ncid, i, NULL, NULL, stride, value);
else
err = nc_put_vars_$1(ncid, i, index, count, stride, value);
if (canConvert) {
if (allInExtRange) {
IF (err)
error("%s", nc_strerror(err));
} else {
IF (err != NC_ERANGE)
error("range error: status = %d", err);
}
} else {
IF (nels > 0 && err != NC_ECHAR)
error("wrong type: status = %d", err);
}
}
}
}
err = nc_close(ncid);
IF (err)
error("nc_close: %s", nc_strerror(err));
check_vars_$1(scratch);
err = remove(scratch);
IF (err)
error("remove of %s failed", scratch);
}
')dnl
TEST_NC_PUT_VARS(text)
TEST_NC_PUT_VARS(uchar)
TEST_NC_PUT_VARS(schar)
TEST_NC_PUT_VARS(short)
TEST_NC_PUT_VARS(int)
TEST_NC_PUT_VARS(long)
TEST_NC_PUT_VARS(float)
TEST_NC_PUT_VARS(double)
dnl TEST_NC_PUT_VARM(TYPE)
dnl
define(`TEST_NC_PUT_VARM',dnl
`dnl
void
test_nc_put_varm_$1(void)
{
int ncid;
int d;
int i;
int j;
int k;
int m;
int err;
int nels;
int nslabs;
int nstarts; /* number of different starts */
size_t start[MAX_RANK];
size_t edge[MAX_RANK];
size_t index[MAX_RANK];
size_t index2[MAX_RANK];
size_t mid[MAX_RANK];
size_t count[MAX_RANK];
size_t sstride[MAX_RANK];
ptrdiff_t stride[MAX_RANK];
ptrdiff_t imap[MAX_RANK];
int canConvert; /* Both text or both numeric */
int allInExtRange; /* all values within external range? */
$1 value[MAX_NELS];
err = nc_create(scratch, NC_CLOBBER, &ncid);
IF (err) {
error("nc_create: %s", nc_strerror(err));
return;
}
def_dims(ncid);
def_vars(ncid);
err = nc_enddef(ncid);
IF (err)
error("nc_enddef: %s", nc_strerror(err));
for (i = 0; i < NVARS; i++) {
canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
assert(var_rank[i] <= MAX_RANK);
assert(var_nels[i] <= MAX_NELS);
for (j = 0; j < var_rank[i]; j++) {
start[j] = 0;
edge[j] = 1;
stride[j] = 1;
imap[j] = 1;
}
err = nc_put_varm_$1(BAD_ID, i, start, edge, stride, imap, value);
IF (err != NC_EBADID)
error("bad ncid: status = %d", err);
err = nc_put_varm_$1(ncid, BAD_VARID, start, edge, stride, imap, value);
IF (err != NC_ENOTVAR)
error("bad var id: status = %d", err);
for (j = 0; j < var_rank[i]; j++) {
if (var_dimid[i][j] > 0) { /* skip record dim */
start[j] = var_shape[i][j] + 1;
err = nc_put_varm_$1(ncid, i, start, edge, stride, imap, value);
if (!canConvert) {
IF(err != NC_ECHAR)
error("conversion: status = %d", err);
} else {
IF (err != NC_EINVALCOORDS)
error("bad start: status = %d", err);
start[j] = 0;
edge[j] = var_shape[i][j] + 1;
err = nc_put_varm_$1(ncid, i, start, edge, stride, imap, value);
IF (err != NC_EEDGE)
error("bad edge: status = %d", err);
edge[j] = 1;
stride[j] = 0;
err = nc_put_varm_$1(ncid, i, start, edge, stride, imap, value);
IF (err != NC_ESTRIDE)
error("bad stride: status = %d", err);
stride[j] = 1;
}
}
}
/* Choose a random point dividing each dim into 2 parts */
/* Put 2^rank (nslabs) slabs so defined */
nslabs = 1;
for (j = 0; j < var_rank[i]; j++) {
mid[j] = roll( var_shape[i][j] );
nslabs *= 2;
}
/* bits of k determine whether to put lower or upper part of dim */
/* choose random stride from 1 to edge */
for (k = 0; k < nslabs; k++) {
nstarts = 1;
for (j = 0; j < var_rank[i]; j++) {
if ((k >> j) & 1) {
start[j] = 0;
edge[j] = mid[j];
}else{
start[j] = mid[j];
edge[j] = var_shape[i][j] - mid[j];
}
sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
nstarts *= stride[j];
}
for (m = 0; m < nstarts; m++) {
err = toMixedBase(m, var_rank[i], sstride, index);
IF (err)
error("error in toMixedBase");
nels = 1;
for (j = 0; j < var_rank[i]; j++) {
count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
nels *= count[j];
index[j] += start[j];
}
/* Random choice of forward or backward */
/* TODO
if ( roll(2) ) {
for (j = 0; j < var_rank[i]; j++) {
index[j] += (count[j] - 1) * stride[j];
stride[j] = -stride[j];
}
}
*/
if (var_rank[i] > 0) {
j = var_rank[i] - 1;
imap[j] = 1;
for (; j > 0; j--)
imap[j-1] = imap[j] * count[j];
}
for (allInExtRange = 1, j = 0; j < nels; j++) {
err = toMixedBase(j, var_rank[i], count, index2);
IF (err)
error("error in toMixedBase");
for (d = 0; d < var_rank[i]; d++)
index2[d] = index[d] + index2[d] * stride[d];
value[j] = hash_$1(var_type[i], var_rank[i], index2,
NCT_ITYPE($1));
allInExtRange = allInExtRange
&& inRange3(value[j], var_type[i], NCT_ITYPE($1));
}
if (var_rank[i] == 0 && i%2 == 0)
err = nc_put_varm_$1(ncid,i,NULL,NULL,NULL,NULL,value);
else
err = nc_put_varm_$1(ncid,i,index,count,stride,imap,value);
if (canConvert) {
if (allInExtRange) {
IF (err)
error("%s", nc_strerror(err));
} else {
IF (err != NC_ERANGE)
error("range error: status = %d", err);
}
} else {
IF (nels > 0 && err != NC_ECHAR)
error("wrong type: status = %d", err);
}
}
}
}
err = nc_close(ncid);
IF (err)
error("nc_close: %s", nc_strerror(err));
check_vars_$1(scratch);
err = remove(scratch);
IF (err)
error("remove of %s failed", scratch);
}
')dnl
TEST_NC_PUT_VARM(text)
TEST_NC_PUT_VARM(uchar)
TEST_NC_PUT_VARM(schar)
TEST_NC_PUT_VARM(short)
TEST_NC_PUT_VARM(int)
TEST_NC_PUT_VARM(long)
TEST_NC_PUT_VARM(float)
TEST_NC_PUT_VARM(double)
void
test_nc_put_att_text(void)
{
int ncid;
int i;
int j;
size_t k;
int err;
text value[MAX_NELS];
err = nc_create(scratch, NC_NOCLOBBER, &ncid);
IF (err) {
error("nc_create: %s", nc_strerror(err));
return;
}
def_dims(ncid);
def_vars(ncid);
{
const char *const tval = "value for bad name";
const size_t tval_len = strlen(tval);
err = nc_put_att_text(ncid, 0, "", tval_len, tval);
IF (err != NC_EBADNAME)
error("should be NC_EBADNAME: status = %d", err);
}
for (i = -1; i < NVARS; i++) {
for (j = 0; j < NATTS(i); j++) {
if (ATT_TYPE(i,j) == NC_CHAR) {
assert(ATT_LEN(i,j) <= MAX_NELS);
err = nc_put_att_text(BAD_ID, i, ATT_NAME(i,j), ATT_LEN(i,j),
value);
IF (err != NC_EBADID)
error("bad ncid: status = %d", err);
err = nc_put_att_text(ncid, BAD_VARID, ATT_NAME(i,j),
ATT_LEN(i,j), value);
IF (err != NC_ENOTVAR)
error("bad var id: status = %d", err);
for (k = 0; k < ATT_LEN(i,j); k++) {
value[k] = hash(ATT_TYPE(i,j), -1, &k);
}
err = nc_put_att_text(ncid, i, ATT_NAME(i,j),
ATT_LEN(i,j), value);
IF (err) {
error("%s", nc_strerror(err));
}
}
}
}
check_atts_text(ncid);
err = nc_close(ncid);
IF (err)
error("nc_close: %s", nc_strerror(err));
err = remove(scratch);
IF (err)
error("remove of %s failed", scratch);
}
dnl TEST_NC_PUT_ATT(TYPE) numeric only
dnl
define(`TEST_NC_PUT_ATT',dnl
`dnl
void
test_nc_put_att_$1(void)
{
int ncid;
int i;
int j;
size_t k;
int err;
$1 value[MAX_NELS];
int allInExtRange; /* all values within external range? */
err = nc_create(scratch, NC_NOCLOBBER, &ncid);
IF (err) {
error("nc_create: %s", nc_strerror(err));
return;
}
def_dims(ncid);
def_vars(ncid);
for (i = -1; i < NVARS; i++) {
for (j = 0; j < NATTS(i); j++) {
if (!(ATT_TYPE(i,j) == NC_CHAR)) {
assert(ATT_LEN(i,j) <= MAX_NELS);
err = nc_put_att_$1(BAD_ID, i, ATT_NAME(i,j), ATT_TYPE(i,j),
ATT_LEN(i,j), value);
IF (err != NC_EBADID)
error("bad ncid: status = %d", err);
err = nc_put_att_$1(ncid, BAD_VARID, ATT_NAME(i,j),
ATT_TYPE(i,j), ATT_LEN(i,j), value);
IF (err != NC_ENOTVAR)
error("bad var id: status = %d", err);
err = nc_put_att_$1(ncid, i, ATT_NAME(i,j), BAD_TYPE,
ATT_LEN(i,j), value);
IF (err != NC_EBADTYPE)
error("bad type: status = %d", err);
for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
value[k] = hash_$1(ATT_TYPE(i,j), -1, &k, NCT_ITYPE($1));
allInExtRange = allInExtRange
&& inRange3(value[k], ATT_TYPE(i,j), NCT_ITYPE($1));
}
err = nc_put_att_$1(ncid, i, ATT_NAME(i,j), ATT_TYPE(i,j),
ATT_LEN(i,j), value);
if (allInExtRange) {
IF (err)
error("%s", nc_strerror(err));
} else {
IF (err != NC_ERANGE)
error("range error: status = %d", err);
}
}
}
}
check_atts_$1(ncid);
err = nc_close(ncid);
IF (err)
error("nc_close: %s", nc_strerror(err));
err = remove(scratch);
IF (err)
error("remove of %s failed", scratch);
}
')dnl
TEST_NC_PUT_ATT(uchar)
TEST_NC_PUT_ATT(schar)
TEST_NC_PUT_ATT(short)
TEST_NC_PUT_ATT(int)
TEST_NC_PUT_ATT(long)
TEST_NC_PUT_ATT(float)
TEST_NC_PUT_ATT(double)
Reference in New Issue View Git Blame Copy Permalink