/other/netcdf_write_matrix/src/nc_test/test_get.c

Large files files are truncated, but you can click here to view the full file

/* Do not edit this file. It is produced from the corresponding .m4 source */
/*********************************************************************
 *   Copyright 1996, UCAR/Unidata
 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
 *   $Id: test_get.m4,v 1.16 2005/03/08 03:04:19 ed Exp $
 *********************************************************************/


#include "tests.h"


void
test_nc_get_var1_text(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    double expect;
    int canConvert;     /* Both text or both numeric */
    text value;

    err = nc_open(testfile, 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_TEXT == NCT_TEXT);
	for (j = 0; j < var_rank[i]; j++)
	    index[j] = 0;
        err = nc_get_var1_text(BAD_ID, i, index, &value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var1_text(ncid, BAD_VARID, index, &value);
        IF (err != NC_ENOTVAR)
	    error("bad var id: status = %d", err);
	for (j = 0; j < var_rank[i]; j++) {
	    index[j] = var_shape[i][j];
	    err = nc_get_var1_text(ncid, i, index, &value);
	    if(!canConvert) {
		IF(err != NC_ECHAR)
			error("conversion: status = %d", err);
	    } else IF (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");
	    expect = hash4( var_type[i], var_rank[i], index, NCT_TEXT );
	    if (var_rank[i] == 0 && i%2 )
		err = nc_get_var1_text(ncid, i, NULL, &value);
	    else
		err = nc_get_var1_text(ncid, i, index, &value);
            if (canConvert) {
		if (inRange3(expect,var_type[i], NCT_TEXT)) {
		    if (expect >= text_min && expect <= text_max) {
			IF (err) {
			    error("%s", nc_strerror(err));
			} else {
			    IF (!equal(value,expect,var_type[i],NCT_TEXT)) {
				error("expected: %G, got: %G", expect,
				    (double) value);
			    } else {
				nok++;
			    }
			}
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
                } else {
                    IF (err != 0 && err != NC_ERANGE)
                        error("OK or Range error: status = %d", err);
		}
	    } else {
		IF (err != NC_ECHAR)
		    error("wrong type: status = %d", err);
	    }
	}
    }
    err = nc_close(ncid);
    IF (err)
	error("nc_close: %s", nc_strerror(err));
    print_nok(nok);
}

void
test_nc_get_var1_uchar(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    double expect;
    int canConvert;     /* Both text or both numeric */
    uchar value;

    err = nc_open(testfile, 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_UCHAR == NCT_TEXT);
	for (j = 0; j < var_rank[i]; j++)
	    index[j] = 0;
        err = nc_get_var1_uchar(BAD_ID, i, index, &value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var1_uchar(ncid, BAD_VARID, index, &value);
        IF (err != NC_ENOTVAR)
	    error("bad var id: status = %d", err);
	for (j = 0; j < var_rank[i]; j++) {
	    index[j] = var_shape[i][j];
	    err = nc_get_var1_uchar(ncid, i, index, &value);
	    if(!canConvert) {
		IF(err != NC_ECHAR)
			error("conversion: status = %d", err);
	    } else IF (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");
	    expect = hash4( var_type[i], var_rank[i], index, NCT_UCHAR );
	    if (var_rank[i] == 0 && i%2 )
		err = nc_get_var1_uchar(ncid, i, NULL, &value);
	    else
		err = nc_get_var1_uchar(ncid, i, index, &value);
            if (canConvert) {
		if (inRange3(expect,var_type[i], NCT_UCHAR)) {
		    if (expect >= uchar_min && expect <= uchar_max) {
			IF (err) {
			    error("%s", nc_strerror(err));
			} else {
			    IF (!equal(value,expect,var_type[i],NCT_UCHAR)) {
				error("expected: %G, got: %G", expect,
				    (double) value);
			    } else {
				nok++;
			    }
			}
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
                } else {
                    IF (err != 0 && err != NC_ERANGE)
                        error("OK or Range error: status = %d", err);
		}
	    } else {
		IF (err != NC_ECHAR)
		    error("wrong type: status = %d", err);
	    }
	}
    }
    err = nc_close(ncid);
    IF (err)
	error("nc_close: %s", nc_strerror(err));
    print_nok(nok);
}

void
test_nc_get_var1_schar(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    double expect;
    int canConvert;     /* Both text or both numeric */
    schar value;

    err = nc_open(testfile, 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_SCHAR == NCT_TEXT);
	for (j = 0; j < var_rank[i]; j++)
	    index[j] = 0;
        err = nc_get_var1_schar(BAD_ID, i, index, &value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var1_schar(ncid, BAD_VARID, index, &value);
        IF (err != NC_ENOTVAR)
	    error("bad var id: status = %d", err);
	for (j = 0; j < var_rank[i]; j++) {
	    index[j] = var_shape[i][j];
	    err = nc_get_var1_schar(ncid, i, index, &value);
	    if(!canConvert) {
		IF(err != NC_ECHAR)
			error("conversion: status = %d", err);
	    } else IF (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");
	    expect = hash4( var_type[i], var_rank[i], index, NCT_SCHAR );
	    if (var_rank[i] == 0 && i%2 )
		err = nc_get_var1_schar(ncid, i, NULL, &value);
	    else
		err = nc_get_var1_schar(ncid, i, index, &value);
            if (canConvert) {
		if (inRange3(expect,var_type[i], NCT_SCHAR)) {
		    if (expect >= schar_min && expect <= schar_max) {
			IF (err) {
			    error("%s", nc_strerror(err));
			} else {
			    IF (!equal(value,expect,var_type[i],NCT_SCHAR)) {
				error("expected: %G, got: %G", expect,
				    (double) value);
			    } else {
				nok++;
			    }
			}
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
                } else {
                    IF (err != 0 && err != NC_ERANGE)
                        error("OK or Range error: status = %d", err);
		}
	    } else {
		IF (err != NC_ECHAR)
		    error("wrong type: status = %d", err);
	    }
	}
    }
    err = nc_close(ncid);
    IF (err)
	error("nc_close: %s", nc_strerror(err));
    print_nok(nok);
}

void
test_nc_get_var1_short(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    double expect;
    int canConvert;     /* Both text or both numeric */
    short value;

    err = nc_open(testfile, 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_SHORT == NCT_TEXT);
	for (j = 0; j < var_rank[i]; j++)
	    index[j] = 0;
        err = nc_get_var1_short(BAD_ID, i, index, &value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var1_short(ncid, BAD_VARID, index, &value);
        IF (err != NC_ENOTVAR)
	    error("bad var id: status = %d", err);
	for (j = 0; j < var_rank[i]; j++) {
	    index[j] = var_shape[i][j];
	    err = nc_get_var1_short(ncid, i, index, &value);
	    if(!canConvert) {
		IF(err != NC_ECHAR)
			error("conversion: status = %d", err);
	    } else IF (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");
	    expect = hash4( var_type[i], var_rank[i], index, NCT_SHORT );
	    if (var_rank[i] == 0 && i%2 )
		err = nc_get_var1_short(ncid, i, NULL, &value);
	    else
		err = nc_get_var1_short(ncid, i, index, &value);
            if (canConvert) {
		if (inRange3(expect,var_type[i], NCT_SHORT)) {
		    if (expect >= short_min && expect <= short_max) {
			IF (err) {
			    error("%s", nc_strerror(err));
			} else {
			    IF (!equal(value,expect,var_type[i],NCT_SHORT)) {
				error("expected: %G, got: %G", expect,
				    (double) value);
			    } else {
				nok++;
			    }
			}
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
                } else {
                    IF (err != 0 && err != NC_ERANGE)
                        error("OK or Range error: status = %d", err);
		}
	    } else {
		IF (err != NC_ECHAR)
		    error("wrong type: status = %d", err);
	    }
	}
    }
    err = nc_close(ncid);
    IF (err)
	error("nc_close: %s", nc_strerror(err));
    print_nok(nok);
}

void
test_nc_get_var1_int(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    double expect;
    int canConvert;     /* Both text or both numeric */
    int value;

    err = nc_open(testfile, 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_INT == NCT_TEXT);
	for (j = 0; j < var_rank[i]; j++)
	    index[j] = 0;
        err = nc_get_var1_int(BAD_ID, i, index, &value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var1_int(ncid, BAD_VARID, index, &value);
        IF (err != NC_ENOTVAR)
	    error("bad var id: status = %d", err);
	for (j = 0; j < var_rank[i]; j++) {
	    index[j] = var_shape[i][j];
	    err = nc_get_var1_int(ncid, i, index, &value);
	    if(!canConvert) {
		IF(err != NC_ECHAR)
			error("conversion: status = %d", err);
	    } else IF (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");
	    expect = hash4( var_type[i], var_rank[i], index, NCT_INT );
	    if (var_rank[i] == 0 && i%2 )
		err = nc_get_var1_int(ncid, i, NULL, &value);
	    else
		err = nc_get_var1_int(ncid, i, index, &value);
            if (canConvert) {
		if (inRange3(expect,var_type[i], NCT_INT)) {
		    if (expect >= int_min && expect <= int_max) {
			IF (err) {
			    error("%s", nc_strerror(err));
			} else {
			    IF (!equal(value,expect,var_type[i],NCT_INT)) {
				error("expected: %G, got: %G", expect,
				    (double) value);
			    } else {
				nok++;
			    }
			}
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
                } else {
                    IF (err != 0 && err != NC_ERANGE)
                        error("OK or Range error: status = %d", err);
		}
	    } else {
		IF (err != NC_ECHAR)
		    error("wrong type: status = %d", err);
	    }
	}
    }
    err = nc_close(ncid);
    IF (err)
	error("nc_close: %s", nc_strerror(err));
    print_nok(nok);
}

void
test_nc_get_var1_long(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    double expect;
    int canConvert;     /* Both text or both numeric */
    long value;

    err = nc_open(testfile, 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_LONG == NCT_TEXT);
	for (j = 0; j < var_rank[i]; j++)
	    index[j] = 0;
        err = nc_get_var1_long(BAD_ID, i, index, &value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var1_long(ncid, BAD_VARID, index, &value);
        IF (err != NC_ENOTVAR)
	    error("bad var id: status = %d", err);
	for (j = 0; j < var_rank[i]; j++) {
	    index[j] = var_shape[i][j];
	    err = nc_get_var1_long(ncid, i, index, &value);
	    if(!canConvert) {
		IF(err != NC_ECHAR)
			error("conversion: status = %d", err);
	    } else IF (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");
	    expect = hash4( var_type[i], var_rank[i], index, NCT_LONG );
	    if (var_rank[i] == 0 && i%2 )
		err = nc_get_var1_long(ncid, i, NULL, &value);
	    else
		err = nc_get_var1_long(ncid, i, index, &value);
            if (canConvert) {
		if (inRange3(expect,var_type[i], NCT_LONG)) {
		    if (expect >= long_min && expect <= long_max) {
			IF (err) {
			    error("%s", nc_strerror(err));
			} else {
			    IF (!equal(value,expect,var_type[i],NCT_LONG)) {
				error("expected: %G, got: %G", expect,
				    (double) value);
			    } else {
				nok++;
			    }
			}
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
                } else {
                    IF (err != 0 && err != NC_ERANGE)
                        error("OK or Range error: status = %d", err);
		}
	    } else {
		IF (err != NC_ECHAR)
		    error("wrong type: status = %d", err);
	    }
	}
    }
    err = nc_close(ncid);
    IF (err)
	error("nc_close: %s", nc_strerror(err));
    print_nok(nok);
}

void
test_nc_get_var1_float(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    double expect;
    int canConvert;     /* Both text or both numeric */
    float value;

    err = nc_open(testfile, 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_FLOAT == NCT_TEXT);
	for (j = 0; j < var_rank[i]; j++)
	    index[j] = 0;
        err = nc_get_var1_float(BAD_ID, i, index, &value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var1_float(ncid, BAD_VARID, index, &value);
        IF (err != NC_ENOTVAR)
	    error("bad var id: status = %d", err);
	for (j = 0; j < var_rank[i]; j++) {
	    index[j] = var_shape[i][j];
	    err = nc_get_var1_float(ncid, i, index, &value);
	    if(!canConvert) {
		IF(err != NC_ECHAR)
			error("conversion: status = %d", err);
	    } else IF (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");
	    expect = hash4( var_type[i], var_rank[i], index, NCT_FLOAT );
	    if (var_rank[i] == 0 && i%2 )
		err = nc_get_var1_float(ncid, i, NULL, &value);
	    else
		err = nc_get_var1_float(ncid, i, index, &value);
            if (canConvert) {
		if (inRange3(expect,var_type[i], NCT_FLOAT)) {
		    if (expect >= float_min && expect <= float_max) {
			IF (err) {
			    error("%s", nc_strerror(err));
			} else {
			    IF (!equal(value,expect,var_type[i],NCT_FLOAT)) {
				error("expected: %G, got: %G", expect,
				    (double) value);
			    } else {
				nok++;
			    }
			}
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
                } else {
                    IF (err != 0 && err != NC_ERANGE)
                        error("OK or Range error: status = %d", err);
		}
	    } else {
		IF (err != NC_ECHAR)
		    error("wrong type: status = %d", err);
	    }
	}
    }
    err = nc_close(ncid);
    IF (err)
	error("nc_close: %s", nc_strerror(err));
    print_nok(nok);
}

void
test_nc_get_var1_double(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    double expect;
    int canConvert;     /* Both text or both numeric */
    double value;

    err = nc_open(testfile, 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_DOUBLE == NCT_TEXT);
	for (j = 0; j < var_rank[i]; j++)
	    index[j] = 0;
        err = nc_get_var1_double(BAD_ID, i, index, &value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var1_double(ncid, BAD_VARID, index, &value);
        IF (err != NC_ENOTVAR)
	    error("bad var id: status = %d", err);
	for (j = 0; j < var_rank[i]; j++) {
	    index[j] = var_shape[i][j];
	    err = nc_get_var1_double(ncid, i, index, &value);
	    if(!canConvert) {
		IF(err != NC_ECHAR)
			error("conversion: status = %d", err);
	    } else IF (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");
	    expect = hash4( var_type[i], var_rank[i], index, NCT_DOUBLE );
	    if (var_rank[i] == 0 && i%2 )
		err = nc_get_var1_double(ncid, i, NULL, &value);
	    else
		err = nc_get_var1_double(ncid, i, index, &value);
            if (canConvert) {
		if (inRange3(expect,var_type[i], NCT_DOUBLE)) {
		    if (expect >= double_min && expect <= double_max) {
			IF (err) {
			    error("%s", nc_strerror(err));
			} else {
			    IF (!equal(value,expect,var_type[i],NCT_DOUBLE)) {
				error("expected: %G, got: %G", expect,
				    (double) value);
			    } else {
				nok++;
			    }
			}
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
                } else {
                    IF (err != 0 && err != NC_ERANGE)
                        error("OK or Range error: status = %d", err);
		}
	    } else {
		IF (err != NC_ECHAR)
		    error("wrong type: status = %d", err);
	    }
	}
    }
    err = nc_close(ncid);
    IF (err)
	error("nc_close: %s", nc_strerror(err));
    print_nok(nok);
}




void
test_nc_get_var_text(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    text value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_TEXT == NCT_TEXT);
        assert(var_rank[i] <= MAX_RANK);
        assert(var_nels[i] <= MAX_NELS);
        err = nc_get_var_text(BAD_ID, i, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var_text(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];
	}
	allInExtRange = allInIntRange = 1;
	for (j = 0; j < nels; j++) {
	    err = toMixedBase(j, var_rank[i], var_shape[i], index);
	    IF (err)
		error("error in toMixedBase 1");
	    expect[j] = hash4(var_type[i], var_rank[i], index, NCT_TEXT);
	    if (inRange3(expect[j],var_type[i], NCT_TEXT)) {
		allInIntRange = allInIntRange && expect[j] >= text_min
			    && expect[j] <= text_max;
	    } else {
		allInExtRange = 0;
	    }
	}
	err = nc_get_var_text(ncid, i, value);
	if (canConvert) {
	    if (allInExtRange) {
		if (allInIntRange) {
		    IF (err)
			error("%s", nc_strerror(err));
		} else {
		    IF (err != NC_ERANGE)
			error("Range error: status = %d", err);
		}
	    } else {
		IF (err != 0 && err != NC_ERANGE)
		    error("OK or Range error: status = %d", err);
	    }
	    for (j = 0; j < nels; j++) {
		if (inRange3(expect[j],var_type[i],NCT_TEXT)
			&& expect[j] >= text_min && expect[j] <= text_max) {
		    IF (!equal(value[j],expect[j],var_type[i],NCT_TEXT)){
			error("value read not that expected");
			if (verbose) {
			    error("\n");
			    error("varid: %d, ", i);
			    error("var_name: %s, ", var_name[i]);
			    error("element number: %d ", j);
			    error("expect: %g", expect[j]);
			    error("got: %g", (double) value[j]);
			}
		    } else {
			nok++;
		    }
		}
	    }
	} 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));
    print_nok(nok);
}

void
test_nc_get_var_uchar(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    uchar value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_UCHAR == NCT_TEXT);
        assert(var_rank[i] <= MAX_RANK);
        assert(var_nels[i] <= MAX_NELS);
        err = nc_get_var_uchar(BAD_ID, i, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var_uchar(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];
	}
	allInExtRange = allInIntRange = 1;
	for (j = 0; j < nels; j++) {
	    err = toMixedBase(j, var_rank[i], var_shape[i], index);
	    IF (err)
		error("error in toMixedBase 1");
	    expect[j] = hash4(var_type[i], var_rank[i], index, NCT_UCHAR);
	    if (inRange3(expect[j],var_type[i], NCT_UCHAR)) {
		allInIntRange = allInIntRange && expect[j] >= uchar_min
			    && expect[j] <= uchar_max;
	    } else {
		allInExtRange = 0;
	    }
	}
	err = nc_get_var_uchar(ncid, i, value);
	if (canConvert) {
	    if (allInExtRange) {
		if (allInIntRange) {
		    IF (err)
			error("%s", nc_strerror(err));
		} else {
		    IF (err != NC_ERANGE)
			error("Range error: status = %d", err);
		}
	    } else {
		IF (err != 0 && err != NC_ERANGE)
		    error("OK or Range error: status = %d", err);
	    }
	    for (j = 0; j < nels; j++) {
		if (inRange3(expect[j],var_type[i],NCT_UCHAR)
			&& expect[j] >= uchar_min && expect[j] <= uchar_max) {
		    IF (!equal(value[j],expect[j],var_type[i],NCT_UCHAR)){
			error("value read not that expected");
			if (verbose) {
			    error("\n");
			    error("varid: %d, ", i);
			    error("var_name: %s, ", var_name[i]);
			    error("element number: %d ", j);
			    error("expect: %g", expect[j]);
			    error("got: %g", (double) value[j]);
			}
		    } else {
			nok++;
		    }
		}
	    }
	} 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));
    print_nok(nok);
}

void
test_nc_get_var_schar(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    schar value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_SCHAR == NCT_TEXT);
        assert(var_rank[i] <= MAX_RANK);
        assert(var_nels[i] <= MAX_NELS);
        err = nc_get_var_schar(BAD_ID, i, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var_schar(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];
	}
	allInExtRange = allInIntRange = 1;
	for (j = 0; j < nels; j++) {
	    err = toMixedBase(j, var_rank[i], var_shape[i], index);
	    IF (err)
		error("error in toMixedBase 1");
	    expect[j] = hash4(var_type[i], var_rank[i], index, NCT_SCHAR);
	    if (inRange3(expect[j],var_type[i], NCT_SCHAR)) {
		allInIntRange = allInIntRange && expect[j] >= schar_min
			    && expect[j] <= schar_max;
	    } else {
		allInExtRange = 0;
	    }
	}
	err = nc_get_var_schar(ncid, i, value);
	if (canConvert) {
	    if (allInExtRange) {
		if (allInIntRange) {
		    IF (err)
			error("%s", nc_strerror(err));
		} else {
		    IF (err != NC_ERANGE)
			error("Range error: status = %d", err);
		}
	    } else {
		IF (err != 0 && err != NC_ERANGE)
		    error("OK or Range error: status = %d", err);
	    }
	    for (j = 0; j < nels; j++) {
		if (inRange3(expect[j],var_type[i],NCT_SCHAR)
			&& expect[j] >= schar_min && expect[j] <= schar_max) {
		    IF (!equal(value[j],expect[j],var_type[i],NCT_SCHAR)){
			error("value read not that expected");
			if (verbose) {
			    error("\n");
			    error("varid: %d, ", i);
			    error("var_name: %s, ", var_name[i]);
			    error("element number: %d ", j);
			    error("expect: %g", expect[j]);
			    error("got: %g", (double) value[j]);
			}
		    } else {
			nok++;
		    }
		}
	    }
	} 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));
    print_nok(nok);
}

void
test_nc_get_var_short(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    short value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_SHORT == NCT_TEXT);
        assert(var_rank[i] <= MAX_RANK);
        assert(var_nels[i] <= MAX_NELS);
        err = nc_get_var_short(BAD_ID, i, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var_short(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];
	}
	allInExtRange = allInIntRange = 1;
	for (j = 0; j < nels; j++) {
	    err = toMixedBase(j, var_rank[i], var_shape[i], index);
	    IF (err)
		error("error in toMixedBase 1");
	    expect[j] = hash4(var_type[i], var_rank[i], index, NCT_SHORT);
	    if (inRange3(expect[j],var_type[i], NCT_SHORT)) {
		allInIntRange = allInIntRange && expect[j] >= short_min
			    && expect[j] <= short_max;
	    } else {
		allInExtRange = 0;
	    }
	}
	err = nc_get_var_short(ncid, i, value);
	if (canConvert) {
	    if (allInExtRange) {
		if (allInIntRange) {
		    IF (err)
			error("%s", nc_strerror(err));
		} else {
		    IF (err != NC_ERANGE)
			error("Range error: status = %d", err);
		}
	    } else {
		IF (err != 0 && err != NC_ERANGE)
		    error("OK or Range error: status = %d", err);
	    }
	    for (j = 0; j < nels; j++) {
		if (inRange3(expect[j],var_type[i],NCT_SHORT)
			&& expect[j] >= short_min && expect[j] <= short_max) {
		    IF (!equal(value[j],expect[j],var_type[i],NCT_SHORT)){
			error("value read not that expected");
			if (verbose) {
			    error("\n");
			    error("varid: %d, ", i);
			    error("var_name: %s, ", var_name[i]);
			    error("element number: %d ", j);
			    error("expect: %g", expect[j]);
			    error("got: %g", (double) value[j]);
			}
		    } else {
			nok++;
		    }
		}
	    }
	} 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));
    print_nok(nok);
}

void
test_nc_get_var_int(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    int value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_INT == NCT_TEXT);
        assert(var_rank[i] <= MAX_RANK);
        assert(var_nels[i] <= MAX_NELS);
        err = nc_get_var_int(BAD_ID, i, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var_int(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];
	}
	allInExtRange = allInIntRange = 1;
	for (j = 0; j < nels; j++) {
	    err = toMixedBase(j, var_rank[i], var_shape[i], index);
	    IF (err)
		error("error in toMixedBase 1");
	    expect[j] = hash4(var_type[i], var_rank[i], index, NCT_INT);
	    if (inRange3(expect[j],var_type[i], NCT_INT)) {
		allInIntRange = allInIntRange && expect[j] >= int_min
			    && expect[j] <= int_max;
	    } else {
		allInExtRange = 0;
	    }
	}
	err = nc_get_var_int(ncid, i, value);
	if (canConvert) {
	    if (allInExtRange) {
		if (allInIntRange) {
		    IF (err)
			error("%s", nc_strerror(err));
		} else {
		    IF (err != NC_ERANGE)
			error("Range error: status = %d", err);
		}
	    } else {
		IF (err != 0 && err != NC_ERANGE)
		    error("OK or Range error: status = %d", err);
	    }
	    for (j = 0; j < nels; j++) {
		if (inRange3(expect[j],var_type[i],NCT_INT)
			&& expect[j] >= int_min && expect[j] <= int_max) {
		    IF (!equal(value[j],expect[j],var_type[i],NCT_INT)){
			error("value read not that expected");
			if (verbose) {
			    error("\n");
			    error("varid: %d, ", i);
			    error("var_name: %s, ", var_name[i]);
			    error("element number: %d ", j);
			    error("expect: %g", expect[j]);
			    error("got: %g", (double) value[j]);
			}
		    } else {
			nok++;
		    }
		}
	    }
	} 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));
    print_nok(nok);
}

void
test_nc_get_var_long(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    long value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_LONG == NCT_TEXT);
        assert(var_rank[i] <= MAX_RANK);
        assert(var_nels[i] <= MAX_NELS);
        err = nc_get_var_long(BAD_ID, i, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var_long(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];
	}
	allInExtRange = allInIntRange = 1;
	for (j = 0; j < nels; j++) {
	    err = toMixedBase(j, var_rank[i], var_shape[i], index);
	    IF (err)
		error("error in toMixedBase 1");
	    expect[j] = hash4(var_type[i], var_rank[i], index, NCT_LONG);
	    if (inRange3(expect[j],var_type[i], NCT_LONG)) {
		allInIntRange = allInIntRange && expect[j] >= long_min
			    && expect[j] <= long_max;
	    } else {
		allInExtRange = 0;
	    }
	}
	err = nc_get_var_long(ncid, i, value);
	if (canConvert) {
	    if (allInExtRange) {
		if (allInIntRange) {
		    IF (err)
			error("%s", nc_strerror(err));
		} else {
		    IF (err != NC_ERANGE)
			error("Range error: status = %d", err);
		}
	    } else {
		IF (err != 0 && err != NC_ERANGE)
		    error("OK or Range error: status = %d", err);
	    }
	    for (j = 0; j < nels; j++) {
		if (inRange3(expect[j],var_type[i],NCT_LONG)
			&& expect[j] >= long_min && expect[j] <= long_max) {
		    IF (!equal(value[j],expect[j],var_type[i],NCT_LONG)){
			error("value read not that expected");
			if (verbose) {
			    error("\n");
			    error("varid: %d, ", i);
			    error("var_name: %s, ", var_name[i]);
			    error("element number: %d ", j);
			    error("expect: %g", expect[j]);
			    error("got: %g", (double) value[j]);
			}
		    } else {
			nok++;
		    }
		}
	    }
	} 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));
    print_nok(nok);
}

void
test_nc_get_var_float(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    float value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_FLOAT == NCT_TEXT);
        assert(var_rank[i] <= MAX_RANK);
        assert(var_nels[i] <= MAX_NELS);
        err = nc_get_var_float(BAD_ID, i, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var_float(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];
	}
	allInExtRange = allInIntRange = 1;
	for (j = 0; j < nels; j++) {
	    err = toMixedBase(j, var_rank[i], var_shape[i], index);
	    IF (err)
		error("error in toMixedBase 1");
	    expect[j] = hash4(var_type[i], var_rank[i], index, NCT_FLOAT);
	    if (inRange3(expect[j],var_type[i], NCT_FLOAT)) {
		allInIntRange = allInIntRange && expect[j] >= float_min
			    && expect[j] <= float_max;
	    } else {
		allInExtRange = 0;
	    }
	}
	err = nc_get_var_float(ncid, i, value);
	if (canConvert) {
	    if (allInExtRange) {
		if (allInIntRange) {
		    IF (err)
			error("%s", nc_strerror(err));
		} else {
		    IF (err != NC_ERANGE)
			error("Range error: status = %d", err);
		}
	    } else {
		IF (err != 0 && err != NC_ERANGE)
		    error("OK or Range error: status = %d", err);
	    }
	    for (j = 0; j < nels; j++) {
		if (inRange3(expect[j],var_type[i],NCT_FLOAT)
			&& expect[j] >= float_min && expect[j] <= float_max) {
		    IF (!equal(value[j],expect[j],var_type[i],NCT_FLOAT)){
			error("value read not that expected");
			if (verbose) {
			    error("\n");
			    error("varid: %d, ", i);
			    error("var_name: %s, ", var_name[i]);
			    error("element number: %d ", j);
			    error("expect: %g", expect[j]);
			    error("got: %g", (double) value[j]);
			}
		    } else {
			nok++;
		    }
		}
	    }
	} 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));
    print_nok(nok);
}

void
test_nc_get_var_double(void)
{
    int ncid;
    int i;
    int j;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nok = 0;      /* count of valid comparisons */
    size_t index[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    double value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_DOUBLE == NCT_TEXT);
        assert(var_rank[i] <= MAX_RANK);
        assert(var_nels[i] <= MAX_NELS);
        err = nc_get_var_double(BAD_ID, i, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_var_double(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];
	}
	allInExtRange = allInIntRange = 1;
	for (j = 0; j < nels; j++) {
	    err = toMixedBase(j, var_rank[i], var_shape[i], index);
	    IF (err)
		error("error in toMixedBase 1");
	    expect[j] = hash4(var_type[i], var_rank[i], index, NCT_DOUBLE);
	    if (inRange3(expect[j],var_type[i], NCT_DOUBLE)) {
		allInIntRange = allInIntRange && expect[j] >= double_min
			    && expect[j] <= double_max;
	    } else {
		allInExtRange = 0;
	    }
	}
	err = nc_get_var_double(ncid, i, value);
	if (canConvert) {
	    if (allInExtRange) {
		if (allInIntRange) {
		    IF (err)
			error("%s", nc_strerror(err));
		} else {
		    IF (err != NC_ERANGE)
			error("Range error: status = %d", err);
		}
	    } else {
		IF (err != 0 && err != NC_ERANGE)
		    error("OK or Range error: status = %d", err);
	    }
	    for (j = 0; j < nels; j++) {
		if (inRange3(expect[j],var_type[i],NCT_DOUBLE)
			&& expect[j] >= double_min && expect[j] <= double_max) {
		    IF (!equal(value[j],expect[j],var_type[i],NCT_DOUBLE)){
			error("value read not that expected");
			if (verbose) {
			    error("\n");
			    error("varid: %d, ", i);
			    error("var_name: %s, ", var_name[i]);
			    error("element number: %d ", j);
			    error("expect: %g", expect[j]);
			    error("got: %g", (double) value[j]);
			}
		    } else {
			nok++;
		    }
		}
	    }
	} 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));
    print_nok(nok);
}




void
test_nc_get_vara_text(void)
{
    int ncid;
    int d;
    int i;
    int j;
    int k;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nslabs;
    int nok = 0;      /* count of valid comparisons */
    size_t start[MAX_RANK];
    size_t edge[MAX_RANK];
    size_t index[MAX_RANK];
    size_t mid[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    text value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_TEXT == 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_get_vara_text(BAD_ID, i, start, edge, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_vara_text(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++) {
	    start[j] = var_shape[i][j];
	    err = nc_get_vara_text(ncid, i, start, edge, value);
            IF (canConvert && err != NC_EINVALCOORDS)
                error("bad index: status = %d", err);
	    start[j] = 0;
	    edge[j] = var_shape[i][j] + 1;
	    err = nc_get_vara_text(ncid, i, start, edge, value);
            IF (canConvert && err != NC_EEDGE)
		error("bad edge: status = %d", err);
	    edge[j] = 1;
	}
            /* Check non-scalars for correct error returned even when */
            /* there is nothing to get (edge[j]==0) */
	if(var_rank[i] > 0) {
	    for (j = 0; j < var_rank[i]; j++) {
		edge[j] = 0;
	    }
	    err = nc_get_vara_text(BAD_ID, i, start, edge, value);
	    IF (err != NC_EBADID) 
		error("bad ncid: status = %d", err);
	    err = nc_get_vara_text(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_get_vara_text(ncid, i, start, edge, value);
		    IF (canConvert && err != NC_EINVALCOORDS)
			error("bad start: status = %d", err);
		    start[j] = 0;
		}
	    }
	    err = nc_get_vara_text(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 */
            /* get 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 get 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];
            }
	    allInExtRange = allInIntRange = 1;
            for (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];
                expect[j] = hash4(var_type[i], var_rank[i], index, NCT_TEXT);
		if (inRange3(expect[j],var_type[i], NCT_TEXT)) {
		    allInIntRange = allInIntRange && expect[j] >= text_min
				&& expect[j] <= text_max;
		} else {
		    allInExtRange = 0;
		}
	    }
            if (var_rank[i] == 0 && i%2)
		err = nc_get_vara_text(ncid, i, NULL, NULL, value);
	    else
		err = nc_get_vara_text(ncid, i, start, edge, value);
            if (canConvert) {
		if (allInExtRange) {
		    if (allInIntRange) {
			IF (err)
			    error("%s", nc_strerror(err));
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
		} else {
		    IF (err != 0 && err != NC_ERANGE)
			error("OK or Range error: status = %d", err);
		}
		for (j = 0; j < nels; j++) {
		    if (inRange3(expect[j],var_type[i],NCT_TEXT)
			    && expect[j] >= text_min && expect[j] <= text_max) {
			IF (!equal(value[j],expect[j],var_type[i],NCT_TEXT)){
			    error("value read not that expected");
			    if (verbose) {
				error("\n");
				error("varid: %d, ", i);
				error("var_name: %s, ", var_name[i]);
				error("element number: %d ", j);
				error("expect: %g", expect[j]);
				error("got: %g", (double) value[j]);
			    }
			} else {
			    nok++;
			}
		    }
		}
            } 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));
    print_nok(nok);
}

void
test_nc_get_vara_uchar(void)
{
    int ncid;
    int d;
    int i;
    int j;
    int k;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all values within internal range? */
    int nels;
    int nslabs;
    int nok = 0;      /* count of valid comparisons */
    size_t start[MAX_RANK];
    size_t edge[MAX_RANK];
    size_t index[MAX_RANK];
    size_t mid[MAX_RANK];
    int canConvert;     /* Both text or both numeric */
    uchar value[MAX_NELS];
    double expect[MAX_NELS];

    err = nc_open(testfile, 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_UCHAR == 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_get_vara_uchar(BAD_ID, i, start, edge, value);
        IF (err != NC_EBADID)
	    error("bad ncid: status = %d", err);
        err = nc_get_vara_uchar(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++) {
	    start[j] = var_shape[i][j];
	    err = nc_get_vara_uchar(ncid, i, start, edge, value);
            IF (canConvert && err != NC_EINVALCOORDS)
                error("bad index: status = %d", err);
	    start[j] = 0;
	    edge[j] = var_shape[i][j] + 1;
	    err = nc_get_vara_uchar(ncid, i, start, edge, value);
            IF (canConvert && err != NC_EEDGE)
		error("bad edge: status = %d", err);
	    edge[j] = 1;
	}
            /* Check non-scalars for correct error returned even when */
            /* there is nothing to get (edge[j]==0) */
	if(var_rank[i] > 0) {
	    for (j = 0; j < var_rank[i]; j++) {
		edge[j] = 0;
	    }
	    err = nc_get_vara_uchar(BAD_ID, i, start, edge, value);
	    IF (err != NC_EBADID) 
		error("bad ncid: status = %d", err);
	    err = nc_get_vara_uchar(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_get_vara_uchar(ncid, i, start, edge, value);
		    IF (canConvert && err != NC_EINVALCOORDS)
			error("bad start: status = %d", err);
		    start[j] = 0;
		}
	    }
	    err = nc_get_vara_uchar(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 */
            /* get 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 get 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];
            }
	    allInExtRange = allInIntRange = 1;
            for (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];
                expect[j] = hash4(var_type[i], var_rank[i], index, NCT_UCHAR);
		if (inRange3(expect[j],var_type[i], NCT_UCHAR)) {
		    allInIntRange = allInIntRange && expect[j] >= uchar_min
				&& expect[j] <= uchar_max;
		} else {
		    allInExtRange = 0;
		}
	    }
            if (var_rank[i] == 0 && i%2)
		err = nc_get_vara_uchar(ncid, i, NULL, NULL, value);
	    else
		err = nc_get_vara_uchar(ncid, i, start, edge, value);
            if (canConvert) {
		if (allInExtRange) {
		    if (allInIntRange) {
			IF (err)
			    error("%s", nc_strerror(err));
		    } else {
			IF (err != NC_ERANGE)
			    error("Range error: status = %d", err);
		    }
		} else {
		    IF (err != 0 && err != NC_ERANGE)
			error("OK or Range error: status = %d", err);
		}
		for (j = 0; j < nels; j++) {
		    if (inRange3(expect[j],var_type[i],NCT_UCHAR)
			    && expect[j] >= uchar_min && expect[j] <= uchar_max) {
			IF (!equal(value[j],expect[j],var_type[i],NCT_UCHAR)){
			    error("value read not that expected");
			    if (verbose) {
				error("\n");
				error("varid: %d, ", i);
				error("var_name: %s, ", var_name[i]);
				error("element number: %d ", j);
				error("expect: %g", expect[j]);
				error("got: %g", (double) value[j]);
			    }
			} else {
			    nok++;
			}
		    }
		}
            } 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));
    print_nok(nok);
}

void
test_nc_get_vara_schar(void)
{
    int ncid;
    int d;
    int i;
    int j;
    int k;
    int err;
    int allInExtRange;	/* all values within external range? */
    int allInIntRange;	/* all …