Logo Search packages:      
Sourcecode: netcdf version File versions  Download package

atttests.c

/*********************************************************************
 *   Copyright 1993, UCAR/Unidata
 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
 *   $Header: /upc/share/CVS/netcdf-3/nctest/atttests.c,v 1.16 2004/11/16 21:33:07 russ Exp $
 *********************************************************************/

#ifdef _MPW
#define           __SEG__  toobig    /* under MPW on MacOS, makes it fit */
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>           /* for free() */
#include "netcdf.h"
#include "testcdf.h"          /* defines in-memory test cdf structure */
#include "add.h"        /* functions to update in-memory netcdf */
#include "error.h"
#include "emalloc.h"
#include "tests.h"
#include "val.h"

#define LEN_OF(array) ((sizeof array) / (sizeof array[0]))


/*
 * Test ncattput
 *    check that new attribute put works in define mode
 *    check that NC_GLOBAL variable id works
 *    check that changing type of existing attribute works in define mode
 *    check that increasing length of attribute works in define mode
 *    check that changing value of existing attribute works in define mode
 *    try with bad datatype, should fail
 *    try with negative length, should fail
 *    try increasing length of attribute in data mode, should fail
 *    try putting new attribute in data mode, should fail
 *    check that changing type of existing attribute works in data mode
 *    check that decreasing length of attribute works in data mode
 *    check that changing value of existing attribute works in data mode
 *    try with bad variable handle, should fail
 *    try with bad netCDF handle, check error
 */
void
test_ncattput(path)
     const char *path;        /* name of writable netcdf file to open */
{
    int nerrs = 0;
    static char pname[] = "test_ncattput";
    int cdfid;                /* netcdf id */
    int ndims;                /* number of dimensions */
    int nvars;                /* number of variables */
    int ngatts_prev, ngatts;  /* number of global attributes */
    int xdimid;               /* id of unlimited dimension */
    int ia, id;
    static char byte_vals[] = {'a', 'b'};
    static char char_vals[] = "chars";
    static short short_vals[] = {-999, 0, 999};
    static nclong long_vals[] = {10, 20};
    static float float_vals[] = {1.5, 2.5, 3.5 };
    static double double_vals[] = {4.5, 5.5, 6.5, 7.5};
    /* 
     * test attributes; it is important for this test that the size 
     * required for the attribute values increases monotonically.
     */
    static struct cdfatt atts[] = {
      {___, "att0", NC_BYTE, LEN_OF(byte_vals), (void *) byte_vals},
      {___, "att1", NC_CHAR, LEN_OF(char_vals), (void *) char_vals},
      {___, "att2", NC_SHORT, LEN_OF(short_vals), (void *) short_vals},
      {___, "att3", NC_LONG, LEN_OF(long_vals), (void *) long_vals},
      {___, "att4", NC_FLOAT, LEN_OF(float_vals), (void *) float_vals},
      {___, "att5", NC_DOUBLE, LEN_OF(double_vals), (void *) double_vals}
    };
    int na = LEN_OF(atts);    /* number of test attributes */
    int ww_id;                /* variable id */
    static struct cdfvar ww = /* new variable */
      {"ww", NC_LONG, 1, ___, 0};
    static struct cdfatt tmp; /* attribute */

    (void) fprintf(stderr, "*** Testing %s ...\t", &pname[5]);

    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
      error("%s: ncopen failed", pname);
      return;
    }
    /* enter define mode */
    if (ncredef(cdfid) == -1) {
      error("%s: cdredef failed", pname);
      ncclose(cdfid); return;
    }
    /* get count of global attributes */
    if (ncinquire(cdfid, &ndims, &nvars, &ngatts, &xdimid) == -1) {
      error("%s: ncinquire failed", pname);
      ncclose(cdfid); return;
    }
    ngatts_prev = ngatts;
    /* in define mode, add global attributes of every type */
    for (ia = 0; ia < na; ia++) {
      if (ncattput(cdfid, NC_GLOBAL, atts[ia].name, atts[ia].type,
                  atts[ia].len, atts[ia].val) == -1) {
          error("%s: ncattput of NC_GLOBAL attribute failed", pname);
          ncclose(cdfid); return;
      }
      add_att(&test, NC_GLOBAL, &atts[ia]); /* keep in-memory netcdf updated */
    }
    /* make sure count of global attributes has been updated */
    if (ncinquire(cdfid, &ndims, &nvars, &ngatts, &xdimid) == -1) {
      error("%s: ncinquire failed", pname);
      ncclose(cdfid); return;
    }
    if (ngatts != ngatts_prev + na) {
      error("%s: number of global = %d, expected %d",
            pname, ngatts, ngatts_prev + na);
      nerrs++;
    }
    /* check with ncattinq and ncattget that NC_GLOBAL attributes put OK */
    for (ia = 0; ia < na; ia++) {
      if (ncattinq(cdfid, NC_GLOBAL, atts[ia].name,
                  &tmp.type, &tmp.len) == -1) {
          error("%s: ncattinq of global attribute failed", pname);
          ncclose(cdfid); return;
      }
      if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
          error("%s: NC_GLOBAL ncattinq got unexpected type or len",
              pname);
          ncclose(cdfid); return;
      }
      /* allocate space to hold the attribute value to be retrieved */
      tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
      if (ncattget(cdfid, NC_GLOBAL, atts[ia].name, tmp.val) == -1) {
          error("%s: ncattget of variable attribute failed", pname);
          ncclose(cdfid); return;
      }
      if (val_cmp(tmp.type, tmp.len, tmp.val, atts[ia].val) != 0) {
          error("%s: ncattget got bad values after put of NC_GLOBAL attrs",
              pname);
          nerrs++;
      }
      free (tmp.val);
    }
    /* add a variable, then variable attributes of every type */
    ww.dims = (int *) emalloc(sizeof(int) * ww.ndims);
    for (id = 0; id < ww.ndims; id++)
      ww.dims[id] = id;
    if ((ww_id = ncvardef(cdfid,
                     ww.name, ww.type, ww.ndims, ww.dims)) == -1) {
      error("%s: ncvardef failed", pname);
      ncclose(cdfid); return;
    }
    add_var(&test, &ww);      /* keep in-memory netcdf in sync */
    for (ia = 0; ia < na; ia++) {
      if (ncattput(cdfid, ww_id,
                  atts[ia].name, atts[ia].type, atts[ia].len, atts[ia].val)
          == -1) {
          error("%s: ncattput of variable attribute failed", pname);
          ncclose(cdfid); return;
      }
      add_att(&test, ww_id, &atts[ia]); /* keep in-memory netcdf updated */
    }
    /* check with ncattinq and ncattget that variable attributes put OK */
    for (ia = 0; ia < na; ia++) {
      if (ncattinq(cdfid, ww_id, atts[ia].name,
                  &tmp.type, &tmp.len) == -1) {
          error("%s: ncattinq of variable attribute failed", pname);
          ncclose(cdfid); return;
      }
      if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
          error("%s: ncattinq for new attribute got bad type or len",
              pname);
          ncclose(cdfid); return;
      }
      /* allocate space to hold the attribute value to be retrieved */
      tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
      if (ncattget(cdfid, ww_id, atts[ia].name, tmp.val) == -1) {
          error("%s: ncattget of variable attribute failed", pname);
          ncclose(cdfid); return;
      }
      if (val_cmp(tmp.type, tmp.len, tmp.val, atts[ia].val) != 0) {
          error("%s: ncattget got bad values after put of variable attrs",
              pname);
          nerrs++;
      }
      free (tmp.val);
    }
    /*
     * check that changing type of existing attribute, increasing 
     * length of attribute, and changing value of existing attribute 
     * work OK in define mode.
     */
    tmp.name = (char *) emalloc(MAX_NC_NAME);
    for (ia = 1; ia < na; ia++) {
      if (ncattput(cdfid, ww_id, atts[ia-1].name, atts[ia].type,
                  atts[ia].len, atts[ia].val) == -1) {
          error("%s: ncattput of larger attribute failed", pname);
          ncclose(cdfid); return;
      }
      tmp.var = atts[ia].var;
      (void) strcpy (tmp.name, atts[ia-1].name);
      tmp.type = atts[ia].type;
      tmp.len = atts[ia].len;
      tmp.val = atts[ia].val;
      add_att(&test, ww_id, &tmp); /* keep in-memory netcdf updated */
    }
    /* check with ncattinq and ncattget that variable attributes put OK */
    for (ia = 1; ia < na; ia++) {
      if (ncattinq(cdfid, ww_id, atts[ia-1].name,
                  &tmp.type, &tmp.len) == -1) {
          error("%s: ncattinq of larger attribute failed", pname);
          ncclose(cdfid); return;
      }
      if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
          error("%s: ncattinq for larger attribute got bad type or len",
              pname);
          ncclose(cdfid); return;
      }
      /* allocate space to hold the attribute value to be retrieved */
      tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
      if (ncattget(cdfid, ww_id, atts[ia-1].name, tmp.val) == -1) {
          error("%s: ncattget of variable attribute failed", pname);
          ncclose(cdfid); return;
      }
      if (val_cmp(tmp.type, tmp.len, tmp.val, atts[ia].val) != 0) {
          error("%s: ncattget got bad values after put of larger attrs",
              pname);
          nerrs++;
      }
      free (tmp.val);
    }
    /* try with bad datatype, should fail */
    if (ncattput(cdfid, ww_id, "bogus_att1", BAD_TYPE,
              atts[0].len, atts[0].val) != -1) {
      error("%s: ncattput should fail with bad type", pname);
      nerrs++;
    }
    /* try with negative length, should fail */
    if (ncattput(cdfid, ww_id, "bogus_att2", atts[0].type,
              -1, atts[0].val) != -1) {
      error("%s: ncattput should fail with bad length", pname);
      nerrs++;
    }
    if (ncendef (cdfid) == -1) {
      error("%s: ncendef failed", pname);
      ncclose(cdfid); return;
    }
    /* in data mode try increasing length of attribute, should fail */
    if (ncattput(cdfid, ww_id, atts[0].name, atts[0].type,
              atts[0].len + 10, atts[0].val) != -1) {
      error("%s: ncattput should fail with increased length in data mode",
            pname);
      nerrs++;
      /* reset to correct length for later tests */
      if (ncattput(cdfid, ww_id, atts[0].name, atts[0].type,
                  atts[0].len, atts[0].val) != -1) {
          error("%s: ncattput failed to reset length in data mode", pname);
          nerrs++;
      }
    }
    /* try creating new attribute in data mode, should fail */
    if (ncattput(cdfid, ww_id, "new_name", atts[0].type,
              atts[0].len, atts[0].val) != -1) {
      error("%s: ncattput of new attribute in data mode should fail",
            pname);
      ncclose(cdfid); return;
    }
    /* 
     * check that changing type of existing attribute, decreasing 
     * length of attribute, and changing value of existing attribute 
     * work OK in data mode
     */
    for (ia = 0; ia < na - 1; ia++) {
      if (ncattput(cdfid, ww_id, atts[ia+1].name, atts[ia].type,
                  atts[ia].len, atts[ia].val) == -1) {
          error("%s: ncattput of smaller attribute failed in data mode",
              pname);
          ncclose(cdfid); return;
      }
      tmp.var = atts[ia].var;
      (void) strcpy (tmp.name, atts[ia+1].name);
      tmp.type = atts[ia].type;
      tmp.len = atts[ia].len;
      tmp.val = atts[ia].val;
      add_att(&test, ww_id, &tmp); /* keep in-memory netcdf updated */
    }
    /* check with ncattinq and ncattget that variable attributes put OK */
    for (ia = 0; ia < na - 1; ia++) {
      if (ncattinq(cdfid, ww_id, atts[ia+1].name, &tmp.type, &tmp.len)
          == -1) {
          error("%s: ncattinq of variable attribute failed in data mode",
              pname);
          ncclose(cdfid); return;
      }
      if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
          error("%s: VARIABLE ncattinq got bad type or len in data mode",
              pname);
          ncclose(cdfid); return;
      }
      /* allocate space to hold the attribute value to be retrieved */
      tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
      if (ncattget(cdfid, ww_id, atts[ia+1].name, tmp.val) == -1) {
          error("%s: ncattget of variable attribute failed in data mode",
              pname);
          ncclose(cdfid); return;
      }
      if (val_cmp(tmp.type, tmp.len, tmp.val, atts[ia].val) != 0) {
          error("%s: ncattget got bad values in data mode", pname);
          nerrs++;
      }
      free (tmp.val);
    }
    /* try with bad variable handle, should fail */
    if (ncattput(cdfid, test.nvars, atts[0].name, atts[0].type, atts[0].len,
              atts[0].val) != -1) {
      error("%s: ncattput should fail with bad variable handle", pname);
      ncclose(cdfid); return;
    }
    if (ncclose (cdfid) == -1) {
      error("%s: ncclose failed", pname);
      return;
    }
    /* try with bad netcdf handle, should fail */
    if (ncattput(cdfid, ww_id, atts[0].name, atts[0].type, atts[0].len,
              atts[0].val) != -1) {
      error("%s: ncattput should fail with bad netcdf handle", pname);
      ncclose(cdfid); return;
    }
    free(tmp.name);
    if (nerrs > 0)
      (void) fprintf(stderr,"FAILED! ***\n");
    else
      (void) fprintf(stderr,"ok ***\n");
}


/*
 * Test ncattinq
 *    check returned values of properly created attributes
 *    try with nonexisting attribute, check error
 *    try with bad variable handle, check error
 *    try with bad netCDF handle, check error
 */
void
test_ncattinq(path)
     const char *path;        /* name of writable netcdf file to open */
{
    int nerrs = 0;
    static char pname[] = "test_ncattinq";
    int cdfid;                /* netcdf id */
    int ia, id;               /* attribute number */
    nc_type type;
    int len;
    int vv_id;                /* variable id */
    static struct cdfvar vv = /* new variable */
      {"vv", NC_SHORT, 2, ___, 0};

    (void) fprintf(stderr, "*** Testing %s ...\t", &pname[5]);

    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
      error("%s: ncopen failed", pname);
      return;
    }
    /* in data mode, check all attributes against test netcdf */
    for (ia = 0; ia < test.natts; ia++) {
      if (ncattinq(cdfid, test.atts[ia].var, test.atts[ia].name,
                  &type, &len) == -1) {
          error("%s: ncattinq failed", pname);
          ncclose(cdfid);
          return;
      }
      if (type != test.atts[ia].type) {
          error("%s: ncattinq returned wrong type", pname);
          ncclose(cdfid);
          return;
      }
      if (len != test.atts[ia].len) {
          error("%s: ncattinq returned wrong len", pname);
          ncclose(cdfid);
          return;
      }
    }

    /* enter define mode */
    if (ncredef(cdfid) == -1) {
      error("%s: cdredef failed", pname);
      ncclose(cdfid); return;
    }
    /* in define mode, add a variable */
    vv.dims = (int *) emalloc(sizeof(int) * vv.ndims);
    for (id = 0; id < vv.ndims; id++)
      vv.dims[id] = id;       /* assumes vv.ndims <= test.ndims */
    if ((vv_id = ncvardef(cdfid, vv.name, vv.type, vv.ndims, vv.dims))
      == -1) {
      error("%s: ncvardef failed", pname);
      ncclose(cdfid); return;
    }
    add_var(&test, &vv);      /* keep in-memory netcdf in sync */

    /* try with nonexisting attribute, should fail */
    if (ncattinq(cdfid, vv_id, "nonesuch", &type, &len) != -1) {
      error("%s: ncattinq should fail with nonexisting attribute", pname);
      ncclose(cdfid); return;
    }
    /* try with bad variable handle, should fail */
    if (ncattinq(cdfid, test.nvars, test.atts[0].name, &type, &len) != -1) {
      error("%s: ncattinq should fail with bad variable id", pname);
      ncclose(cdfid); return;
    }
    /* in define mode check all attributes against test netcdf */
    for (ia = 0; ia < test.natts; ia++) {
      if (ncattinq(cdfid, test.atts[ia].var, test.atts[ia].name,
                  &type, &len) == -1) {
          error("%s: ncattinq in define mode failed", pname);
          ncclose(cdfid);
          return;
      }
      if (type != test.atts[ia].type) {
          error("%s: ncattinq in define mode returned wrong type", pname);
          ncclose(cdfid);
          return;
      }
      if (len != test.atts[ia].len) {
          error("%s: ncattinq in define mode returned wrong len", pname);
          ncclose(cdfid);
          return;
      }
    }
    if (ncendef (cdfid) == -1) {
      error("%s: ncendef failed", pname);
      ncclose(cdfid); return;
    }
    if (ncclose (cdfid) == -1) {
      error("%s: ncclose failed", pname);
      return;
    }
    if (ncattinq(cdfid, NC_GLOBAL, test.atts[0].name, &type, &len) != -1) {
      error("%s: ncattinq should fail with bad cdfid", pname);
      nerrs++;
    }
    if (nerrs > 0)
      (void) fprintf(stderr,"FAILED! ***\n");
    else
      (void) fprintf(stderr,"ok ***\n");
}


/*
 * Test ncattget
 *    check that NC_GLOBAL variable id works
 *    check in both modes
 *    check that proper call worked after ncattput
 *    try with bad variable handle, check error
 *    try with nonexisting attribute, check error
 *    try with bad netCDF handle, check error
 */
void
test_ncattget(path)
     const char *path;        /* name of writable netcdf file to open */
{
    int nerrs = 0;
    int cdfid;                /* netcdf id */
    int ia, id;
    static struct cdfatt tmp; /* attribute */
    int uu_id;                /* variable id */
    static struct cdfvar uu = /* variable */
      {"uu", NC_LONG, 2, ___, 0};
    static nclong uumax = 1000;     /* attribute value */
    static struct cdfatt vmax = /* attribute */
      {___, "valid_max", NC_LONG, 1, (void *) &uumax};

    static char pname[] = "test_ncattget";

    (void) fprintf(stderr, "*** Testing %s ...\t", &pname[5]);

    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
      error("%s: ncopen failed", pname);
      return;
    }
    /* enter define mode */
    if (ncredef(cdfid) == -1) {
      error("%s: cdredef failed", pname);
      ncclose(cdfid); return;
    }
    /* add a variable */
    uu.dims = (int *) emalloc(sizeof(int) * uu.ndims);
    for (id = 0; id < uu.ndims; id++)
      uu.dims[id] = id;
    if ((uu_id = ncvardef(cdfid,
                     uu.name, uu.type, uu.ndims, uu.dims)) == -1) {
      error("%s: ncvardef failed", pname);
      ncclose(cdfid); return;
    }
    add_var(&test, &uu);      /* keep in-memory netcdf in sync */

    /* add an attribute */
    if (ncattput(cdfid, uu_id,
              vmax.name, vmax.type, vmax.len, vmax.val)
      == -1) {
      error("%s: ncattput of variable attribute failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, uu_id, &vmax); /* keep in-memory netcdf updated */

    /* in define mode, check all attributes values against test netcdf */
    for (ia = 0; ia < test.natts; ia++) {
      if (ncattinq(cdfid, test.atts[ia].var, test.atts[ia].name,
                  &tmp.type, &tmp.len) == -1) {
          error("%s: ncattinq in define mode failed", pname);
          ncclose(cdfid); return;
      }
      if (tmp.type != test.atts[ia].type) {
          error("%s: ncattinq in define mode returned wrong type", pname);
          ncclose(cdfid);
          return;
      }
      if (tmp.len != test.atts[ia].len) {
          error("%s: ncattinq in define mode returned wrong len", pname);
          ncclose(cdfid); return;
      }
      /* allocate space to hold the attribute value to be retrieved */
      tmp.val = emalloc(tmp.len * nctypelen(tmp.type));
      if (ncattget(cdfid, test.atts[ia].var, test.atts[ia].name, tmp.val)
          == -1) {
          error("%s: ncattget of variable attribute failed in define mode",
              pname);
          ncclose(cdfid); return;
      }
      if (val_cmp(tmp.type, tmp.len, tmp.val, test.atts[ia].val) != 0) {
          error("%s: ncattget got bad values in define mode", pname);
          error("   cdfid=%d, varname=%s, attname=%s, type=%d, len=%d",
              cdfid, test.vars[test.atts[ia].var].name,
              test.atts[ia].name, test.atts[ia].type, test.atts[ia].len);
          (void)fprintf(stderr,"should have got:");
          val_out(test.atts[ia].type, test.atts[ia].len,
                     test.atts[ia].val);
          (void)fprintf(stderr,"    instead got:");
          val_out(tmp.type, tmp.len, tmp.val);
          nerrs++;
      }
      free (tmp.val);
    }
    if (ncendef (cdfid) == -1) {
      error("%s: ncendef failed", pname);
      ncclose(cdfid); return;
    }

    /* in data mode, check all attributes values against test netcdf */
    for (ia = 0; ia < test.natts; ia++) {
      if (ncattinq(cdfid, test.atts[ia].var, test.atts[ia].name,
                  &tmp.type, &tmp.len) == -1) {
          error("%s: ncattinq failed", pname);
          ncclose(cdfid);
          return;
      }
      if (tmp.type != test.atts[ia].type) {
          error("%s: ncattinq returned wrong type", pname);
          ncclose(cdfid);
          return;
      }
      if (tmp.len != test.atts[ia].len) {
          error("%s: ncattinq returned wrong len", pname);
          ncclose(cdfid);
          return;
      }
      /* allocate space to hold the attribute value to be retrieved */
      tmp.val = emalloc(tmp.len * nctypelen(tmp.type));
      if (ncattget(cdfid, test.atts[ia].var, test.atts[ia].name, tmp.val)
          == -1) {
          error("%s: ncattget of variable attribute failed in data mode",
              pname);
          ncclose(cdfid); return;
      }
      if (val_cmp(tmp.type, tmp.len, tmp.val, test.atts[ia].val) != 0) {
          error("%s: ncattget got bad values in data mode", pname);
          error("   cdfid=%d, varname=%s, attname=%s, type=%d, len=%d",
              cdfid, test.vars[test.atts[ia].var].name,
              test.atts[ia].name, test.atts[ia].type, test.atts[ia].len);
          (void)fprintf(stderr,"should have got:");
          val_out(test.atts[ia].type, test.atts[ia].len,
                     test.atts[ia].val);
          (void)fprintf(stderr,"    instead got:");
          val_out(tmp.type, tmp.len, tmp.val);
          nerrs++;
      }
      free (tmp.val);
    }
    /* try with bad variable handle, should fail */
    if (ncattget(cdfid, test.nvars, vmax.name, vmax.val) != -1) {
      error("%s: ncattget should fail with bad variable handle", pname);
      ncclose(cdfid); return;
    }
    /* try getting non-existent attribute, should fail */
    if (ncattget(cdfid, uu_id, "nonesuch", vmax.val) != -1) {
      error("%s: ncattget should fail with nonexistant attribute", pname);
      ncclose(cdfid); return;
    }
    if (ncclose (cdfid) == -1) {
      error("%s: ncclose failed", pname);
      return;
    }
    /* try with bad netcdf handle, should fail */
    if (ncattget(cdfid, uu_id, vmax.name, vmax.val) != -1) {
      error("%s: ncattput should fail with bad netcdf handle", pname);
      ncclose(cdfid); return;
    }
    if (nerrs > 0)
      (void) fprintf(stderr,"FAILED! ***\n");
    else
      (void) fprintf(stderr,"ok ***\n");
}


/*
 * Test ncattcopy
 *    check that NC_GLOBAL variable for source or target works
 *    check that new attribute put works with target in define mode
 *    check that old attribute put works with target in data mode
 *    check that changing type and length of an attribute work OK
 *    try with same cdfid for source and target, different variables
 *    try with same cdfid for source and target, same variable
 *    try with nonexisting attribute, check error
 *    try with bad source or target netCDF handles, check error
 *    try with bad source or target variable handle, check error
 */
void
test_ncattcopy(path1, path2)
     const char *path1;       /* name of input netcdf file to open */
     const char *path2;       /* name of output netcdf file to create */
{
    int nerrs = 0;
    static char pname[] = "test_ncattcopy";
    int cdfid, cdfid2;        /* netcdf id */
    int id;             /* dimension id */
    int tt_id;                /* variable id */
    static struct cdfvar tt = /* new variable for source netcdf */
      {"tt", NC_LONG, 1, ___, 0};
    int tu_id, tu2_id;        /* variable ids */
    static struct cdfvar tu = /* new variable for target netcdf */
      {"tu", NC_DOUBLE, 2, ___, 0};
    static double double_vals[] = {-1., -2.};
    static float float_vals[] = {-1., -2.};
    static struct cdfatt att =      /* attribute */
      {___, "att", NC_DOUBLE, LEN_OF(double_vals), (void *) double_vals};
    static struct cdfatt att2 =     /* attribute */
      {___, "att", NC_FLOAT, LEN_OF(float_vals), (void *) float_vals};
    static struct cdfatt tmp;       /* attribute */

    (void) fprintf(stderr, "*** Testing %s ...\t", &pname[5]);

    if ((cdfid = ncopen(path1, NC_WRITE)) == -1) {
      error("%s: ncopen failed", pname);
      return;
    }
    /* opened OK, enter define mode */
    if (ncredef(cdfid) == -1) {
      error("%s: ncredef failed on source", pname);
      ncclose(cdfid); return;
    }
    /* in define mode, add a global attribute, a variable and an attribute */
    if (ncattput(cdfid, NC_GLOBAL, att.name, att.type, att.len, att.val) == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, NC_GLOBAL, &att); /* keep in-memory netcdf consistent */
    tt.dims = (int *) emalloc(sizeof(int) * tt.ndims);
    for (id=0; id < tt.ndims; id++)
      tt.dims[0] = id;
    if ((tt_id=ncvardef(cdfid, tt.name, tt.type, tt.ndims, tt.dims)) == -1) {
      error("%s: ncvardef failed", pname);
      ncclose(cdfid); return;
    }
    add_var(&test, &tt);      /* keep in-memory netcdf consistent */
    if (ncattput(cdfid, tt_id, att.name, att.type, att.len, att.val) == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, tt_id, &att); /* keep in-memory netcdf consistent */

    tu.dims = (int *) emalloc(sizeof(int) * tu.ndims);
    for (id = 0; id < tu.ndims; id++)
      tu.dims[id] = id;
    if ((tu_id=ncvardef(cdfid, tu.name, tu.type, tu.ndims, tu.dims)) == -1) {
      error("%s: ncvardef failed", pname);
      ncclose(cdfid); return;
    }
    add_var(&test, &tu);      /* keep in-memory netcdf consistent */
    if (ncattput(cdfid, tu_id, att.name, att.type, att.len, att.val) == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, tu_id, &att); /* keep in-memory netcdf consistent */
    if (ncendef (cdfid) == -1) {
      error("%s: ncendef failed", pname);
      ncclose(cdfid); return;
    }
    /* first (source) netcdf is in data mode */
    /* create second netCDF to copy attributes to */
    if ((cdfid2 = nccreate(path2, NC_CLOBBER)) == -1) {
      error("%s: nccreate failed", pname);
      return;
    }
    /* create dimensions and variable in second netcdf */
    for (id = 0; id < tu.ndims; id++)     { /* copy dimensions from source */
      if ((tu.dims[id] =ncdimdef(cdfid2, test.dims[id].name,
                            test.dims[id].size)) == -1) {
          error("%s: ncdimdef failed", pname);
          ncclose(cdfid); ncclose(cdfid2); return;
      }
    }
    if ((tu2_id=ncvardef(cdfid2, tu.name, tu.type, tu.ndims, tu.dims)) == -1) {
      error("%s: ncvardef failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* try copying NC_GLOBAL attribute from source to target */
    if (ncattcopy(cdfid, NC_GLOBAL, att.name, cdfid2, NC_GLOBAL) == -1) {
      error("%s: ncattcopy on NC_GLOBAL attribute '%s' failed",
            pname, att.name);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* check that copy worked with ncattinq and ncattget */
    if (ncattinq(cdfid2, NC_GLOBAL, att.name, &tmp.type, &tmp.len) == -1) {
      error("%s: ncattinq of NC_GLOBAL attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (att.type != tmp.type || att.len != tmp.len) {
      error("%s: NC_GLOBAL ncattinq got unexpected type or len", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* allocate space to hold the attribute value to be retrieved */
    tmp.val = emalloc(att.len * nctypelen(att.type));
    if (ncattget(cdfid2, NC_GLOBAL, att.name, tmp.val) == -1) {
      error("%s: ncattget of variable attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (val_cmp(tmp.type, tmp.len, tmp.val, att.val) != 0) {
      error("%s: ncattget got bad values after put of NC_GLOBAL attrs",
            pname);
      nerrs++;
    }
    free (tmp.val);
    /* try copying variable attribute from source to target */
    if (ncattcopy(cdfid, tt_id, att.name, cdfid2, tu2_id) == -1) {
      error("%s: ncattcopy failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* check that copy worked with ncattinq and ncattget */
    if (ncattinq(cdfid2, tu2_id, att.name, &tmp.type, &tmp.len) == -1) {
      error("%s: ncattinq of variable attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (att.type != tmp.type || att.len != tmp.len) {
      error("%s: variable ncattinq got unexpected type or len", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* allocate space to hold the attribute value to be retrieved */
    tmp.val = emalloc(att.len * nctypelen(att.type));
    if (ncattget(cdfid2, tu2_id, att.name, tmp.val) == -1) {
      error("%s: ncattget of variable attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (val_cmp(tmp.type, tmp.len, tmp.val, att.val) != 0) {
      error("%s: ncattget got bad values after copy of variable attrs",
            pname);
      nerrs++;
    }
    free (tmp.val);

    /* 
     * check that old attribute put works with target in data mode, 
     * also checks that changing type and length of an attribute works OK
     */
    if (ncendef (cdfid2) == -1) {
      error("%s: ncendef failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* change attribute to shorter attribute */
    if (ncattput(cdfid, NC_GLOBAL, att2.name, att2.type, att2.len, att2.val)
      == -1) {
      error("%s: ncattput of shorter NC_GLOBAL attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    add_att(&test, NC_GLOBAL, &att2); /* keep in-memory netcdf consistent */
    /* copy shorter attribute on existing attribute */
    if (ncattcopy(cdfid, NC_GLOBAL, att2.name, cdfid2, tu2_id) == -1) {
      error("%s: ncattcopy of shorter attribute on old attribute failed",
            pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* check that copy worked with ncattinq and ncattget */
    if (ncattinq(cdfid2, tu2_id, att2.name, &tmp.type, &tmp.len) == -1) {
      error("%s: ncattinq of variable attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (att2.type != tmp.type || att2.len != tmp.len) {
      error("%s: variable ncattinq got unexpected type or len", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* allocate space to hold the attribute value to be retrieved */
    tmp.val = emalloc(att2.len * nctypelen(att2.type));
    if (ncattget(cdfid2, tu2_id, att2.name, tmp.val) == -1) {
      error("%s: ncattget of variable attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (val_cmp(tmp.type, tmp.len, tmp.val, att2.val) != 0) {
      error("%s: ncattget got bad values after copy of variable attrs",
            pname);
      nerrs++;
    }
    free (tmp.val);

    /* try copying with same source and target netcdf, different variables */
    /* copy shorter attribute on existing attribute */
    if (ncattcopy(cdfid, NC_GLOBAL, att2.name, cdfid, tu_id) == -1) {
      error("%s: ncattcopy of shorter NC_GLOBAL attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    add_att(&test, tu_id, &att2); /* keep in-memory netcdf consistent */
    /* check that copy worked with ncattinq and ncattget */
    if (ncattinq(cdfid, tu_id, att2.name, &tmp.type, &tmp.len) == -1) {
      error("%s: ncattinq of variable attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (att2.type != tmp.type || att2.len != tmp.len) {
      error("%s: variable ncattinq got unexpected type or len", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* allocate space to hold the attribute value to be retrieved */
    tmp.val = emalloc(att2.len * nctypelen(att2.type));
    if (ncattget(cdfid, tu_id, att2.name, tmp.val) == -1) {
      error("%s: ncattget of variable attribute failed", pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (val_cmp(tmp.type, tmp.len, tmp.val, att2.val) != 0) {
      error("%s: ncattget got bad values after copy of variable attrs",
            pname);
      nerrs++;
    }
    free (tmp.val);

    /* try with same cdfid for source and target, same variable */
    if (ncattcopy(cdfid, tu_id, att.name, cdfid, tu_id) == -1) {
      error("%s: ncattcopy failed with identical source and target",
            pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* try with nonexisting attribute, check error */
    if (ncattcopy(cdfid, tt_id, "nonesuch", cdfid, tu_id) != -1) {
      error("%s: ncattcopy should fail with bad attribute name",
            pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    /* try with bad source or target variable handle, check error */
    if (ncattcopy(cdfid, test.nvars, att.name, cdfid, tu_id) != -1) {
      error("%s: ncattcopy should fail with bad source variable id",
            pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (ncattcopy(cdfid, tt_id, att.name, cdfid, 2) != -1) {
      error("%s: ncattcopy should fail with bad target variable id",
            pname);
      ncclose(cdfid); ncclose(cdfid2); return;
    }
    if (ncclose (cdfid2) == -1) {
      error("%s: ncclose failed", pname);
      ncclose(cdfid); return;
    }
    /* try with bad source or target netCDF handles, check error */
    if (ncattcopy(cdfid, tt_id, att.name, cdfid2, tu_id) != -1) {
      error("%s: ncattcopy should fail with bad target netcdf id",
            pname);
      ncclose(cdfid); return;
    }
    if (ncclose (cdfid) == -1) {
      error("%s: ncclose failed", pname);
      return;
    }
    if (ncattcopy(cdfid, tt_id, att.name, cdfid2, tu_id) != -1) {
      error("%s: ncattcopy should fail with bad netcdf id", pname);
      nerrs++;
    }
    if (nerrs > 0)
      (void) fprintf(stderr,"FAILED! ***\n");
    else
      (void) fprintf(stderr,"ok ***\n");
}


/*
 * Test ncattname
 *    check that NC_GLOBAL variable id works
 *    check in both modes
 *    check that proper call worked after ncattput
 *    try with bad netCDF handle, check error
 *    try with bad variable handle, check error
 *    try with bad attribute number, check error
 */
void
test_ncattname(path)
     const char *path;        /* name of writable netcdf file to open */
{
    int nerrs = 0;
    static char pname[] = "test_ncattname";
    int cdfid;                /* netcdf id */
    struct cdfatt tmp;        /* attributes */
    int ia, ib;               /* attribute numbers */
    int iv;             /* variable id */
    static short short_vals[] = {3, 4, 5};
    static struct cdfatt att =      /* attribute */
      {___, ___, NC_SHORT, LEN_OF(short_vals), (void *) short_vals};

    (void) fprintf(stderr, "*** Testing %s ...\t", &pname[5]);

    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
      error("%s: ncopen failed", pname);
      return;
    }
    /* opened OK, enter define mode */
    if (ncredef(cdfid) == -1) {
      error("%s: ncredef failed", pname);
      ncclose(cdfid); return;
    }
    /* for each NC_GLOBAL attribute, get name and compare with expected name */
    att.name = (char *) emalloc(MAX_NC_NAME);
    ib = 0;
    for (ia = 0; ia < test.ngatts; ia++) {
      if (ncattname(cdfid, NC_GLOBAL, ia, att.name) == -1) {
          error("%s: ncattname failed on global attribute", pname);
          ncclose(cdfid); return;
      }
      /* find number of next global attribute */
      while (ib < test.natts && test.atts[ib].var != NC_GLOBAL)
        ib++;
      if (ib >= test.natts) {
          error("%s: test problem, expected global attribute not found",
              pname);
          ncclose(cdfid); return;
      }
      if (strcmp(att.name, test.atts[ib].name) != 0) {
          error("%s: NC_GLOBAL attribute name `%s' instead of expected `%s'",
              pname, att.name, test.atts[ib].name);
          nerrs++;
      }
      ib++;
    }
    /* for each variable attribute, get name and compare with expected name */
    for (iv = 0; iv < test.nvars; iv++) {
      ib = 0;
      for (ia = 0; ia < test.vars[iv].natts; ia++) {
          if (ncattname(cdfid, iv, ia, att.name) == -1) {
            error("%s: ncattname failed on variable attribute", pname);
            ncclose(cdfid); return;
          }
          /* find number of next attribute */
          while (ib < test.natts && test.atts[ib].var != iv)
            ib++;
          if (ib >= test.natts) {
            error("%s: problem  in test, expected attribute not found",
                  pname);
            ncclose(cdfid); return;
          }
          if (strcmp(att.name, test.atts[ib].name) != 0) {
            error("%s: variable '%s' name `%s' instead of expected `%s'",
                  pname, test.vars[iv].name, att.name, test.atts[ib].name);
            nerrs++;
          }
          ib++;
      }
    }
    /* in define mode, add a global attribute */
    (void) strcpy(att.name,"attx");
    if (ncattput(cdfid, NC_GLOBAL, att.name, att.type, att.len, att.val)
      == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, NC_GLOBAL, &att); /* keep in-memory netcdf consistent */
    /* test that ncattname works immediately after ncattput */
    tmp.name = (char *) emalloc(MAX_NC_NAME);
    if (ncattname(cdfid, NC_GLOBAL, test.ngatts-1, tmp.name) == -1) {
      error("%s: ncattname failed on variable attribute", pname);
      ncclose(cdfid); return;
    }
    if (strcmp(att.name, tmp.name) != 0) {
      error("%s: immediate NC_GLOBAL name `%s' instead of expected `%s'",
            pname, tmp.name, att.name);
      nerrs++;
    }
    if (ncendef (cdfid) == -1) {
      error("%s: ncendef failed", pname);
      ncclose(cdfid); return;
    }
    /* in data mode */
    /* for each NC_GLOBAL attribute, get name and compare with expected name */
    ib = 0;
    for (ia = 0; ia < test.ngatts; ia++) {
      if (ncattname(cdfid, NC_GLOBAL, ia, att.name) == -1) {
          error("%s: ncattname failed on global attribute", pname);
          ncclose(cdfid); return;
      }
      /* find number of next global attribute */
      while (ib < test.natts && test.atts[ib].var != NC_GLOBAL)
        ib++;
      if (ib >= test.natts) {
          error("%s: test problem, expected global attribute not found",
              pname);
          ncclose(cdfid); return;
      }
      if (strcmp(att.name, test.atts[ib].name) != 0) {
          error("%s: NC_GLOBAL attribute name `%s' instead of expected `%s'",
              pname, att.name, test.atts[ib].name);
          nerrs++;
      }
      ib++;
    }
    /* for each variable attribute, get name and compare with expected name */
    for (iv = 0; iv < test.nvars; iv++) {
      ib = 0;
      for (ia = 0; ia < test.vars[iv].natts; ia++) {
          if (ncattname(cdfid, iv, ia, att.name) == -1) {
            error("%s: ncattname failed on variable attribute", pname);
            ncclose(cdfid); return;
          }
          /* find number of next attribute */
          while (ib < test.natts && test.atts[ib].var != iv)
            ib++;
          if (ib >= test.natts) {
            error("%s: problem  in test, expected attribute not found",
                  pname);
            ncclose(cdfid); return;
          }
          if (strcmp(att.name, test.atts[ib].name) != 0) {
            error("%s: variable '%s' name `%s' instead of expected `%s'",
                  pname, test.vars[iv].name, att.name, test.atts[ib].name);
            nerrs++;
          }
          ib++;
      }
    }
    /* try with bad variable handle, check error */
    if (ncattname(cdfid, test.nvars, 0, att.name) != -1) {
      error("%s: ncattname should fail with bad variable handle", pname);
      ncclose(cdfid); return;
    }
    /* try with bad attribute number, check error */
    if (ncattname(cdfid, NC_GLOBAL, -1, att.name) != -1) {
      error("%s: ncattname should fail with negative number", pname);
      ncclose(cdfid); return;
    }
    if (ncattname(cdfid, NC_GLOBAL, test.ngatts, att.name) != -1) {
      error("%s: ncattname should fail with too-high number", pname);
      ncclose(cdfid); return;
    }
    if (ncclose (cdfid) == -1) {
      error("%s: ncclose failed", pname);
      nerrs++;
      return;
    }
    /* try with bad netCDF handle, check error */
    if (ncattname(cdfid, NC_GLOBAL, 0, att.name) != -1) {
      error("%s: ncattname shoul fail with bad cdfid", pname);
      nerrs++;
    }
    free (tmp.name);
    free (att.name);
    if (nerrs > 0)
      (void) fprintf(stderr,"FAILED! ***\n");
    else
      (void) fprintf(stderr,"ok ***\n");
}


/*
 * Test ncattrename
 *    check that proper rename worked with ncattinq, ncattget
 *    try renaming to existing attribute name, check error
 *    try with nonexisting attribute, check error
 *    try with bad variable handle, check error
 *    try in data mode, check error
 *    try with bad netCDF handle, check error
 */
void
test_ncattrename(path)
     const char *path;        /* name of writable netcdf file to open */
{
    int nerrs = 0;
    static char pname[] = "test_ncattrename";
    int cdfid;                /* netcdf id */
    static char newname[] = "shorter";
    static char longername[] = "longer_name";
    struct cdfatt tmp;        /* attributes */
    static short short_vals[] = {3, 4, 5};
    static struct cdfatt atty =     /* attribute */
      {___, "long_name", NC_SHORT, LEN_OF(short_vals), (void *) short_vals};
    static struct cdfatt attz =     /* attribute */
      {___, "arggh", NC_SHORT, LEN_OF(short_vals), (void *) short_vals};
    int ynum;                 /* attribute number */

    (void) fprintf(stderr, "*** Testing %s ...\t", &pname[5]);

    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
      error("%s: ncopen failed", pname);
      return;
    }
    /* opened OK, enter define mode */
    if (ncredef(cdfid) == -1) {
      error("%s: cdredef failed", pname);
      ncclose(cdfid); return;
    }
    /* in define mode, add two attributes */
    if (ncattput(cdfid, NC_GLOBAL, atty.name, atty.type, atty.len,
              atty.val) == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, NC_GLOBAL, &atty); /* keep in-memory netcdf in sync */
    ynum = test.natts-1;      /* number of attribute just put */
    if (ncattput(cdfid, NC_GLOBAL, attz.name, attz.type, attz.len,
              attz.val) == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, NC_GLOBAL, &attz); /* keep in-memory netcdf in sync */

    /* rename first attribute to shorter name */
    if (ncattrename(cdfid, NC_GLOBAL, atty.name, newname) == -1) {
      error("%s: ncattrename failed", pname);
      ncclose(cdfid); return;
    }
    (void) strcpy(test.atts[ynum].name, newname); /* keep test consistent */
    /* check new name with ncattinq */
    if (ncattinq(cdfid, NC_GLOBAL, newname, &tmp.type, &tmp.len) == -1) {
      error("%s: ncattinq of renamed attribute failed", pname);
      ncclose(cdfid); return;
    }
    if (atty.type != tmp.type || atty.len != tmp.len) {
      error("%s: NC_GLOBAL ncattinq got unexpected type or len", pname);
      ncclose(cdfid); return;
    }
    /* allocate space to hold the attribute value to be retrieved */
    tmp.val = emalloc(atty.len * nctypelen(atty.type));
    if (ncattget(cdfid, NC_GLOBAL, newname, tmp.val) == -1) {
      error("%s: ncattget of variable attribute failed", pname);
      ncclose(cdfid); return;
    }
    if (val_cmp(tmp.type, tmp.len, tmp.val, atty.val) != 0) {
      error("%s: ncattget got bad values after rename attrs", pname);
      nerrs++;
    }
    if (ncattinq(cdfid, NC_GLOBAL, atty.name, &tmp.type, &tmp.len) != -1) {
      error("%s: ncattrename left attribute with old name", pname);
      ncclose(cdfid); return;
    }
    /* try to rename second attribute same as first, should fail */
    if (ncattrename(cdfid, NC_GLOBAL, attz.name, newname) != -1) {
      error("%s: ncattrename should have failed with used name", pname);
      ncclose(cdfid); return;
    }
    /* try to rename second attribute with a longer name */
    if (ncattrename(cdfid, NC_GLOBAL, attz.name, longername) == -1) {
      error("%s: ncattrename failed with longer name", pname);
      ncclose(cdfid); return;
    }
    /* try with bad variable handle, check for failure */
    if (ncattrename(cdfid, test.nvars, newname, atty.name) != -1) {
      error("%s: ncattrename should have failed on bad variable id", pname);
      ncclose(cdfid); return;
    }
    /* try with bad attribute name, check for failure */
    if (ncattrename(cdfid, NC_GLOBAL, "nonesuch", newname) != -1) {
      error("%s: ncattrename should have failed on bad attribute name",
            pname);
      ncclose(cdfid); return;
    }
    if (ncendef (cdfid) == -1) {
      error("%s: ncendef failed", pname);
      ncclose(cdfid); return;
    }
    /* in data mode change name to even shorter and check value */
    if (ncattrename(cdfid, NC_GLOBAL, newname, "short") == -1) {
      error("%s: ncattrename to shorter name failed in data mode", pname);
      ncclose(cdfid); return;
    }
    if (ncattrename(cdfid, NC_GLOBAL, "short", "plugh") == -1) {
      error("%s: ncattrename to same length failed in data mode", pname);
      ncclose(cdfid); return;
    }
    if (ncattget(cdfid, NC_GLOBAL, "plugh", tmp.val) == -1) {
      error("%s: ncgetatt of renamed attribute failed in data mode", pname);
      ncclose(cdfid); return;
    }
    if (val_cmp(tmp.type, tmp.len, tmp.val, atty.val) != 0) {
      error("%s: ncattget got bad values after data mode rename", pname);
      nerrs++;
    }
    free (tmp.val);
    if (ncclose (cdfid) == -1) {
      error("%s: ncclose failed", pname);
      return;
    }
    /* should fail, since bad handle */
    if (ncattrename(cdfid, NC_GLOBAL, newname, atty.name) != -1) {
      error("%s: ncattrename should fail with bad cdfid", pname);
      ncclose(cdfid); return;
    }
    if (nerrs > 0)
      (void) fprintf(stderr,"FAILED! ***\n");
    else
      (void) fprintf(stderr,"ok ***\n");
}


/*
 * Test ncattdel
 *    check that proper delete worked     
 *    try with bad netCDF handle, check error
 *    try with bad variable handle, check error
 *    try with nonexisting attribute, check error
 *    try in data mode, check error
 */
void
test_ncattdel(path)
     const char *path;        /* name of writable netcdf file to open */
{
    int nerrs = 0;
    static char pname[] = "test_ncattdel";
    int cdfid;                /* netcdf id */
    static short short_vals[] = {-1, -2, -3 };
    static struct cdfatt yaa =      /* attribute */
      {___, "yet_another_attribute", NC_SHORT, LEN_OF(short_vals),
         (void *) short_vals};
    int id;             /* dimension id */
    int yav_id;               /* variable id */
    static struct cdfvar yav =      /* new variable for target netcdf */
      {"yet_another_variable", NC_DOUBLE, 2, ___, 0};
    struct cdfvar vtmp;       /* variable */
    struct cdfatt atmp;       /* attribute */
    int ndims;                /* number of dimensions */
    int nvars;                /* number of variables */
    int ngatts1, ngatts2;     /* number of global attributes */
    int natts;                /* number of variable attributes */
    int xdimid;               /* id of unlimited dimension */

    (void) fprintf(stderr, "*** Testing %s ...\t", &pname[5]);

    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
      error("%s: ncopen failed", pname);
      return;
    }
    /* opened OK, enter define mode */
    if (ncredef(cdfid) == -1) {
      error("%s: cdredef failed", pname);
      ncclose(cdfid); return;
    }
    /* in define mode, add global attribute, variable, variable attribute */
    if (ncattput(cdfid, NC_GLOBAL, yaa.name, yaa.type, yaa.len, yaa.val) == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, NC_GLOBAL, &yaa); /* keep in-memory netcdf in sync */
    yav.dims = (int *) emalloc(sizeof(int) * yav.ndims);
    for (id = 0; id < yav.ndims; id++)
      yav.dims[id] = id;
    if ((yav_id=ncvardef(cdfid, yav.name, yav.type, yav.ndims, yav.dims))
      == -1) {
      error("%s: ncvardef failed", pname);
      ncclose(cdfid); return;
    }
    add_var(&test, &yav);     /* keep in-memory netcdf consistent */
    if (ncattput(cdfid, yav_id, yaa.name, yaa.type, yaa.len, yaa.val) == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, yav_id, &yaa); /* keep in-memory netcdf consistent */

    /* get number of global attributes, number of attributes for variable */
    if (ncinquire(cdfid, &ndims, &nvars, &ngatts1, &xdimid) == -1) {
      error("%s: ncinquire in data mode failed", pname);
      ncclose(cdfid); return;
    }
    vtmp.dims = (int *) emalloc(sizeof(int) * MAX_VAR_DIMS);
    vtmp.name = (char *) emalloc(MAX_NC_NAME);
    if (ncvarinq(cdfid, yav_id, vtmp.name, &vtmp.type, &vtmp.ndims, vtmp.dims,
              &natts) == -1) {
      error("%s: ncvarinq failed", pname);
      ncclose(cdfid); return;
    }    

    /* delete global attribute and check that it's gone */
    if (ncattdel(cdfid, NC_GLOBAL, yaa.name) == -1) {
      error("%s: ncattdel failed", pname);
      ncclose(cdfid); return;
    }
    del_att(&test, NC_GLOBAL, &yaa); /* keep in-memory netcdf consistent */
    if (ncinquire(cdfid, &ndims, &nvars, &ngatts2, &xdimid) == -1) {
      error("%s: ncinquire failed", pname);
      ncclose(cdfid); return;
    }
    if (ngatts2 != ngatts1 - 1) {
      error("%s: NC_GLOBAL attribute deleted, but ngatts did not decrement",
            pname);
      ncclose(cdfid); return;
    }
    if (ncattinq(cdfid, NC_GLOBAL, yaa.name, &atmp.type, &atmp.len) != -1) {
      error("%s: ncattinq on deleted NC_GLOBAL attribute should fail", pname);
      ncclose(cdfid); return;
    }

    /* delete variable attribute and check that it's gone */
    if (ncattdel(cdfid, yav_id, yaa.name) == -1) {
      error("%s: ncattdel failed", pname);
      ncclose(cdfid); return;
    }
    del_att(&test, yav_id, &yaa); /* keep in-memory netcdf consistent */
    if (ncvarinq(cdfid, yav_id, vtmp.name, &vtmp.type, &vtmp.ndims,
              vtmp.dims, &vtmp.natts) == -1) {
      error("%s: ncvarinq failed", pname);
      ncclose(cdfid); return;
    }
    if (vtmp.natts != natts - 1) {
      error("%s: NC_GLOBAL attribute deleted, but ngatts did not decrement",
            pname);
      ncclose(cdfid); return;
    }
    if (ncattinq(cdfid, yav_id, yaa.name, &atmp.type, &atmp.len) != -1) {
      error("%s: ncattinq on deleted variable attribute should fail",
            pname);
      ncclose(cdfid); return;
    }
    /* re-add global attribute, variable, variable attribute */
    if (ncattput(cdfid, NC_GLOBAL, yaa.name, yaa.type, yaa.len, yaa.val) == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, NC_GLOBAL, &yaa); /* keep in-memory netcdf in sync */
    if (ncattput(cdfid, yav_id, yaa.name, yaa.type, yaa.len, yaa.val) == -1) {
      error("%s: ncattput failed", pname);
      ncclose(cdfid); return;
    }
    add_att(&test, yav_id, &yaa); /* keep in-memory netcdf consistent */
    /* try on nonexistent attribute, should fail */
    if (ncattdel(cdfid, yav_id, "nonesuch") != -1) {
      error("%s: ncattdel should fail on bogus attribute", pname);
      ncclose(cdfid); return;
    }
    /* try on bad variable id, should fail */
    if (ncattdel(cdfid, test.nvars, yaa.name) != -1) {
      error("%s: ncattdel should fail on bad variable id", pname);
      ncclose(cdfid); return;
    }
    if (ncendef (cdfid) == -1) {
      error("%s: ncendef failed", pname);
      ncclose(cdfid); return;
    }
    /* in data mode, should fail */
    if (ncattdel(cdfid, NC_GLOBAL, yaa.name) != -1) {
      error("%s: ncattdel in data mode should fail", pname);
      ncclose(cdfid); return;
    }
    if (ncclose (cdfid) == -1) {
      error("%s: ncclose failed", pname);
      return;
    }
    /* try on bad netcdf handle, should fail */
    if (ncattdel(cdfid, yav_id, yaa.name) != -1) {
      error("%s: ncattdel should fail on bad netcdf id", pname);
      nerrs++;
    }
    free(vtmp.dims);
    free(vtmp.name);
    free(yav.dims);
    if (nerrs > 0)
      (void) fprintf(stderr,"FAILED! ***\n");
    else
      (void) fprintf(stderr,"ok ***\n");
}

Generated by  Doxygen 1.6.0   Back to index