1/*********************************************************************
2 *   Copyright 1996, UCAR/Unidata
3 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
4 *   $Id: test_read.c 2792 2014-10-27 06:02:59Z wkliao $
5 *********************************************************************/
6
7#include "tests.h"
8
9/*
10 * Test nc_strerror.
11 *    Try on a bad error status.
12 *    Test for each defined error status.
13 */
14void
15test_nc_strerror(void)
16{
17    int i;
18    const char *message;
19
20    static const struct {
21 int status;
22 const char *msg;
23    } ncerrs[] = {
24 {NC_NOERR, "No error"},
25 {NC_EBADID, "NetCDF: Not a valid ID"},
26 {NC_ENFILE, "NetCDF: Too many files open"},
27 {NC_EEXIST, "NetCDF: File exists && NC_NOCLOBBER"},
28 {NC_EINVAL, "NetCDF: Invalid argument"},
29 {NC_EPERM, "NetCDF: Write to read only"},
30 {NC_ENOTINDEFINE, "NetCDF: Operation not allowed in data mode"},
31 {NC_EINDEFINE, "NetCDF: Operation not allowed in define mode"},
32 {NC_EINVALCOORDS, "NetCDF: Index exceeds dimension bound"},
33 {NC_EMAXDIMS, "NetCDF: NC_MAX_DIMS exceeded"},
34 {NC_ENAMEINUSE, "NetCDF: String match to name in use"},
35 {NC_ENOTATT, "NetCDF: Attribute not found"},
36 {NC_EMAXATTS, "NetCDF: NC_MAX_ATTRS exceeded"},
37 {NC_EBADTYPE, "NetCDF: Not a valid data type or _FillValue type mismatch"},
38 {NC_EBADDIM, "NetCDF: Invalid dimension ID or name"},
39 {NC_EUNLIMPOS, "NetCDF: NC_UNLIMITED in the wrong index"},
40 {NC_EMAXVARS, "NetCDF: NC_MAX_VARS exceeded"},
41 {NC_ENOTVAR, "NetCDF: Variable not found"},
42 {NC_EGLOBAL, "NetCDF: Action prohibited on NC_GLOBAL varid"},
43 {NC_ENOTNC, "NetCDF: Unknown file format"},
44 {NC_ESTS, "NetCDF: In Fortran, string too short"},
45 {NC_EMAXNAME, "NetCDF: NC_MAX_NAME exceeded"},
46 {NC_EUNLIMIT, "NetCDF: NC_UNLIMITED size already in use"},
47 {NC_ENORECVARS, "NetCDF: nc_rec op when there are no record vars"},
48 {NC_ECHAR, "NetCDF: Attempt to convert between text & numbers"},
49 {NC_EEDGE, "NetCDF: Start+count exceeds dimension bound"},
50 {NC_ESTRIDE, "NetCDF: Illegal stride"},
51 {NC_EBADNAME, "NetCDF: Name contains illegal characters"},
52 {NC_ERANGE, "NetCDF: Numeric conversion not representable"},
53 {NC_ENOMEM, "NetCDF: Memory allocation (malloc) failure"},
54 {NC_EVARSIZE, "NetCDF: One or more variable sizes violate format constraints"},
55 {NC_EDIMSIZE, "NetCDF: Invalid dimension size"}
56    };
57
58    /* Try on a bad error status */
59    /* Dmh: allow trailing extra info */
60    message = nc_strerror(-666);/* should fail */
61    IF (strncmp(message, "Unknown Error", strlen("Unknown Error")) != 0)
62 error("nc_strerror on bad error status returned: %s", message);
63
64    /* Try on each legitimate error status */
65    /* Dmh: allow trailing extra info */
66    for (i=0; i<LEN_OF(ncerrs); i++) {
67 const char *message = nc_strerror(ncerrs[i].status);
68 IF (strncmp(messagencerrs[i].msg, strlen(ncerrs[i].msg)) != 0)
69     error("nc_strerror(%d) should return `%s', not `%s'",
70   ncerrs[i].statusncerrs[i].msgmessage);
71    }
72}
73
74
75/*
76 * Test nc_open.
77 * If in read-only section of tests,
78 *    Try to open a non-existent netCDF file, check error return.
79 *    Open a file that is not a netCDF file, check error return.
80 *    Open a netCDF file with a bad mode argument, check error return.
81 *    Open a netCDF file with NC_NOWRITE mode, try to write, check error.
82 *    Try to open a netcdf twice, check whether returned netcdf ids different.
83 * If in writable section of tests,
84 *    Open a netCDF file with NC_WRITE mode, write something, close it.
85 * On exit, any open netCDF files are closed.
86 */
87void
88test_nc_open(void)
89{
90    int err;
91    int ncid;
92    int ncid2;
93
94    /* Try to open a nonexistent file */
95    err = file_open("tooth-fairy.nc", NC_NOWRITE, &ncid);/* should fail */
96    IF (err == NC_NOERR)
97 error("nc_open of nonexistent file should have failed");
98#ifndef USE_PARALLEL
99    IF (! NC_ISSYSERR(err))
100 error("nc_open of nonexistent file should have returned system error");
101#endif
102
103    /* Open a file that is not a netCDF file.  But need a portable
104     * test that also works for cross-compiles ... */
105    /* err = nc_open("nc_test.o", NC_NOWRITE, &ncid);/\* should fail *\/ */
106    /* IF (err != NC_ENOTNC) */
107    /*  error("nc_open of non-netCDF file: status = %d", err); */
108
109    /* Open a netCDF file in read-only mode, check that write fails */
110    err = file_open(testfileNC_NOWRITE, &ncid);
111    IF (err)
112 error("nc_open: %s", nc_strerror(err));
113    err = nc_redef(ncid); /* should fail */
114    IF (err != NC_EPERM)
115 error("nc_redef of read-only file should fail");
116    /* Opened OK, see if can open again and get a different netCDF ID */
117    err = file_open(testfileNC_NOWRITE, &ncid2);
118    IF (err)
119 error("nc_open: %s", nc_strerror(err));
120    else {
121 (void) nc_close(ncid2);
122    }
123    IF (ncid2 == ncid)
124 error("netCDF IDs for first and second nc_open calls should differ");
125
126    err = file_create(scratchNC_NOCLOBBER, &ncid2);
127    IF (err)
128       error("nc_create: %s", nc_strerror(err));
129    else
130       (void) nc_close(ncid2);
131    err = file_open(scratchNC_WRITE, &ncid2);
132    IF (err)
133       error("nc_open: %s", nc_strerror(err));
134    else
135       (void) nc_close(ncid2);
136    err = remove(scratch);
137    IF (err)
138       error("remove of %s failed", scratch);
139
140    err = nc_close(ncid);
141    IF (err)
142 error("nc_close: %s", nc_strerror(err));
143}
144
145
146/*
147 * Test nc_close.
148 *    Try to close a netCDF file twice, check whether second close fails.
149 *    Try on bad handle, check error return.
150 *    Try in define mode and data mode.
151 */
152void
153test_nc_close(void)
154{
155    int nciderr;
156
157    err = file_open(testfileNC_NOWRITE, &ncid);
158    IF (err)
159 error("nc_open: %s", nc_strerror(err));
160
161    /* Close a netCDF file twice, second time should fail */
162    err = nc_close(ncid);
163    IF (err)
164 error("nc_close failed: %s", nc_strerror(err));
165    err = nc_close(ncid);
166    IF (err != NC_EBADID)
167 error("nc_close of closed file should have failed");
168
169    /* Try with a bad netCDF ID */
170    err = nc_close(BAD_ID);/* should fail */
171    IF (err != NC_EBADID)
172 error("nc_close with bad netCDF ID returned wrong error (%d)", err);
173
174    /* Close in data mode */
175    err = file_open(testfileNC_NOWRITE, &ncid);
176    IF (err)
177 error("nc_open: %s", nc_strerror(err));
178    err = nc_close(ncid);
179    IF (err)
180 error("nc_close in data mode failed: %s", nc_strerror(err));
181
182    err = file_create(scratchNC_NOCLOBBER, &ncid);
183    IF (err)
184       error("nc_create: %s", nc_strerror(err));
185    err = nc_close(ncid);
186    IF (err)
187       error("nc_close in define mode: %s", nc_strerror(err));
188    err = remove(scratch);
189    IF (err)
190       error("remove of %s failed", scratch);
191}
192
193
194/*
195 * Test nc_inq.
196 *    Try on bad handle, check error return.
197 *    Try in data mode, check returned values.
198 *    Try asking for subsets of info.
199 * If in writable section of tests,
200 *    Try in define mode, after adding an unlimited dimension, variable.
201 * On exit, any open netCDF files are closed.
202 */
203void
204test_nc_inq(void)
205{
206    int ncid;
207    int ndims; /* number of dimensions */
208    int nvars; /* number of variables */
209    int ngatts; /* number of global attributes */
210    int recdim; /* id of unlimited dimension */
211    int err;
212
213    err = file_open(testfileNC_NOWRITE, &ncid);
214    IF (err)
215 error("nc_open: %s", nc_strerror(err));
216
217    /* Try on bad handle */
218    err = nc_inq(BAD_ID, 0, 0, 0, 0);
219    IF (err != NC_EBADID)
220 error("bad ncid: status = %d", err);
221
222    err = nc_inq(ncid, &ndims, &nvars, &ngatts, &recdim);
223    IF (err)
224 error("nc_inq: %s", nc_strerror(err));
225    else IF (ndims != NDIMS)
226 error("nc_inq: wrong number of dimensions returned, %d", ndims);
227    else IF (nvars != numVars)
228 error("nc_inq: wrong number of variables returned, %d", nvars);
229    else IF (ngatts != numGatts)
230 error("nc_inq: wrong number of global atts returned, %d", ngatts);
231    else IF (recdim != RECDIM)
232 error("nc_inq: wrong record dimension ID returned, %d", recdim);
233
234    /* Inguire for no info (useless, but should still work) */
235    err = nc_inq(ncid, 0, 0, 0, 0);
236    IF (err)
237 error("nc_inq for no info failed: %s", nc_strerror(err));
238
239    /* Inguire for subsets of info */
240    ngatts = numGatts - 1; /* wipe out previous correct value */
241    err = nc_inq(ncid, 0, 0, &ngatts, 0);
242    IF (err)
243 error("nc_inq for one item failed: %s", nc_strerror(err));
244    else IF (ngatts != numGatts)
245 error("nc_inq subset: wrong number of global atts returned, %d", ngatts);
246    ndims = NDIMS - 1;
247    nvars = numVars - 1;
248    err = nc_inq(ncid, &ndims, &nvars, 0, 0);
249    IF (err)
250 error("nc_inq for two items failed: %s", nc_strerror(err));
251    else IF (ndims != NDIMS)
252 error("nc_inq subset: wrong number of dimensions returned, %d", ndims);
253    else IF (nvars != numVars)
254 error("nc_inq subset: wrong number of variables returned, %d", nvars);
255
256    { /* tests using netCDF scratch file */
257 int ncid2; /* for scratch netCDF dataset */
258
259#ifdef TEST_PNETCDF
260        err = nc_create_par(scratchNC_NOCLOBBER|NC_PNETCDFMPI_COMM_WORLDMPI_INFO_NULL, &ncid2);
261#else
262        err = nc_create(scratchNC_NOCLOBBER, &ncid2);
263#endif
264        IF (err) {
265            error("nc_create: %s", nc_strerror(err));
266 } else { /* add dim, var, gatt, check inq */
267     int ndims0;
268     int nvars0;
269     int ngatts0;
270     int recdim0;
271     err = nc_enddef(ncid2); /* enter data mode */
272     IF (err)
273 error("nc_enddef: %s", nc_strerror(err));
274     err = nc_inq(ncid2, &ndims0, &nvars0, &ngatts0, &recdim0);
275     IF (err)
276 error("nc_inq: %s", nc_strerror(err));
277     err = nc_redef(ncid2); /* enter define mode */
278     IF (err)
279 error("nc_redef: %s", nc_strerror(err));
280     /* Check that inquire still works in define mode */
281     err = nc_inq(ncid2, &ndims, &nvars, &ngatts, &recdim);
282     IF (err)
283 error("nc_inq in define mode: %s", nc_strerror(err));
284     else IF (ndims != ndims0)
285 error("nc_inq in define mode: ndims wrong, %d", ndims);
286     else IF (nvars != nvars0)
287 error("nc_inq in define mode: nvars wrong, %d", nvars);
288     else IF (ngatts != ngatts0)
289 error("nc_inq in define mode: ngatts wrong, %d", ngatts);
290     else IF (recdim != recdim0)
291 error("nc_inq in define mode: recdim wrong, %d", recdim);
292
293     {
294 int didvid;
295 /* Add dim, var, global att */
296 err = nc_def_dim(ncid2, "inqd", 1L, &did);
297 IF (err)
298     error("nc_def_dim: %s", nc_strerror(err));
299 err = nc_def_var(ncid2, "inqv", NC_FLOAT, 0, 0, &vid);
300 IF (err)
301     error("nc_def_var: %s", nc_strerror(err));
302     }
303     err = nc_put_att_text(ncid2NC_GLOBAL, "inqa", 1+strlen("stuff"),
304    "stuff");
305     IF (err)
306 error("nc_put_att_text: %s", nc_strerror(err));
307
308     /* Make sure nc_inq sees the additions while in define mode */
309     err = nc_inq(ncid2, &ndims, &nvars, &ngatts, &recdim);
310     IF (err)
311 error("nc_inq in define mode: %s", nc_strerror(err));
312     else IF (ndims != ndims0 + 1)
313 error("nc_inq in define mode: ndims wrong, %d", ndims);
314     else IF (nvars != nvars0 + 1)
315 error("nc_inq in define mode: nvars wrong, %d", nvars);
316     else IF (ngatts != ngatts0 + 1)
317 error("nc_inq in define mode: ngatts wrong, %d", ngatts);
318     err = nc_enddef(ncid2);
319     IF (err)
320 error("nc_enddef: %s", nc_strerror(err));
321
322     /* Make sure nc_inq stills sees additions in data mode */
323     err = nc_inq(ncid2, &ndims, &nvars, &ngatts, &recdim);
324     IF (err)
325 error("nc_inq failed in data mode: %s", nc_strerror(err));
326     else IF (ndims != ndims0 + 1)
327 error("nc_inq in define mode: ndims wrong, %d", ndims);
328     else IF (nvars != nvars0 + 1)
329 error("nc_inq in define mode: nvars wrong, %d", nvars);
330     else IF (ngatts != ngatts0 + 1)
331 error("nc_inq in define mode: ngatts wrong, %d", ngatts);
332     (void) nc_close(ncid2);
333     err = remove(scratch);
334     IF (err)
335 error("remove of %s failed", scratch);
336 }
337    }
338
339    err = nc_close(ncid);
340    IF (err)
341 error("nc_close: %s", nc_strerror(err));
342}
343
344
345void
346test_nc_inq_natts(void)
347{
348    int ncid;
349    int ngatts; /* number of global attributes */
350    int err;
351
352    err = nc_inq_natts(BAD_ID, &ngatts);
353    IF (err != NC_EBADID)
354 error("bad ncid: status = %d", err);
355    err = file_open(testfileNC_NOWRITE, &ncid);
356    IF (err)
357 error("nc_open: %s", nc_strerror(err));
358    err = nc_inq_natts(ncid, &ngatts);
359    IF (err)
360 error("nc_inq_natts: %s", nc_strerror(err));
361    else IF (ngatts != numGatts)
362 error("nc_inq_natts: wrong number of global atts returned, %d", ngatts);
363    err = nc_close(ncid);
364    IF (err)
365 error("nc_close: %s", nc_strerror(err));
366}
367
368
369void
370test_nc_inq_ndims(void)
371{
372    int ncid;
373    int ndims;
374    int err;
375
376    err = nc_inq_ndims(BAD_ID, &ndims);
377    IF (err != NC_EBADID)
378 error("bad ncid: status = %d", err);
379    err = file_open(testfileNC_NOWRITE, &ncid);
380    IF (err)
381 error("nc_open: %s", nc_strerror(err));
382    err = nc_inq_ndims(ncid, &ndims);
383    IF (err)
384 error("nc_inq_ndims: %s", nc_strerror(err));
385    else IF (ndims != NDIMS)
386 error("nc_inq_ndims: wrong number returned, %d", ndims);
387    err = nc_close(ncid);
388    IF (err)
389 error("nc_close: %s", nc_strerror(err));
390}
391
392
393void
394test_nc_inq_nvars(void)
395{
396    int ncid;
397    int nvars;
398    int err;
399
400    err = nc_inq_nvars(BAD_ID, &nvars);
401    IF (err != NC_EBADID)
402 error("bad ncid: status = %d", err);
403    err = file_open(testfileNC_NOWRITE, &ncid);
404    IF (err)
405 error("nc_open: %s", nc_strerror(err));
406    err = nc_inq_nvars(ncid, &nvars);
407    IF (err)
408 error("nc_inq_nvars: %s", nc_strerror(err));
409    else IF (nvars != numVars)
410 error("nc_inq_nvars: wrong number returned, %d", nvars);
411    err = nc_close(ncid);
412    IF (err)
413 error("nc_close: %s", nc_strerror(err));
414}
415
416
417void
418test_nc_inq_unlimdim(void)
419{
420    int ncid;
421    int unlimdim;
422    int err;
423
424    err = nc_inq_unlimdim(BAD_ID, &unlimdim);
425    IF (err != NC_EBADID)
426 error("bad ncid: status = %d", err);
427    err = file_open(testfileNC_NOWRITE, &ncid);
428    IF (err)
429 error("nc_open: %s", nc_strerror(err));
430    err = nc_inq_unlimdim(ncid, &unlimdim);
431    IF (err)
432 error("nc_inq_unlimdim: %s", nc_strerror(err));
433    else IF (unlimdim != RECDIM)
434 error("nc_inq_unlimdim: wrong number returned, %d", unlimdim);
435    err = nc_close(ncid);
436    IF (err)
437 error("nc_close: %s", nc_strerror(err));
438}
439
440
441void
442test_nc_inq_dimid(void)
443{
444    int ncid;
445    int dimid;
446    int i;
447    int err;
448
449    err = file_open(testfileNC_NOWRITE, &ncid);
450    IF (err)
451 error("nc_open: %s", nc_strerror(err));
452    err = nc_inq_dimid(ncid, "noSuch", &dimid);
453    IF (err != NC_EBADDIM)
454 error("bad dim name: status = %d", err);
455    for (i = 0; i < NDIMSi++) {
456 err = nc_inq_dimid(BAD_IDdim_name[i], &dimid);
457 IF (err != NC_EBADID)
458     error("bad ncid: status = %d", err);
459 err = nc_inq_dimid(nciddim_name[i], &dimid);
460 IF (err)
461     error("nc_inq_dimid: %s", nc_strerror(err));
462 else IF (dimid != i)
463     error("expected %d, got %d", idimid);
464    }
465    err = nc_close(ncid);
466    IF (err)
467 error("nc_close: %s", nc_strerror(err));
468}
469
470
471void
472test_nc_inq_dim(void)
473{
474    int ncid;
475    int i;
476    int err;
477    char name[NC_MAX_NAME];
478    size_t length;
479
480    err = file_open(testfileNC_NOWRITE, &ncid);
481    IF (err)
482 error("nc_open: %s", nc_strerror(err));
483    for (i = 0; i < NDIMSi++) {
484 err = nc_inq_dim(BAD_IDiname, &length);
485        IF (err != NC_EBADID)
486     error("bad ncid: status = %d", err);
487 err = nc_inq_dim(ncidBAD_DIMIDname, &length);
488        IF (err != NC_EBADDIM)
489     error("bad dimid: status = %d", err);
490 err = nc_inq_dim(ncidi, 0, 0);
491 IF (err)
492     error("nc_inq_dim: %s", nc_strerror(err));
493 err = nc_inq_dim(ncidiname, &length);
494 IF (err)
495     error("nc_inq_dim: %s", nc_strerror(err));
496 else IF (strcmp(dim_name[i],name))
497     error("name expected: %s, got: %s",dim_name[i],name);
498 else IF (dim_len[i] != length)
499     error("size expected: %d, got: %d",dim_len[i],length);
500 err = nc_inq_dim(ncidiname, 0);
501        IF (err)
502     error("nc_inq_dim: %s", nc_strerror(err));
503 else IF (strcmp(dim_name[i],name))
504     error("name expected: %s, got: %s",dim_name[i],name);
505 err = nc_inq_dim(ncidi, 0, &length);
506        IF (err)
507     error("nc_inq_dim: %s", nc_strerror(err));
508 else IF (dim_len[i] != length)
509     error("size expected: %d, got: %d",dim_len[i],length);
510    }
511    err = nc_close(ncid);
512    IF (err)
513 error("nc_close: %s", nc_strerror(err));
514}
515
516
517void
518test_nc_inq_dimlen(void)
519{
520    int ncid;
521    int i;
522    int err;
523    size_t length;
524
525    err = file_open(testfileNC_NOWRITE, &ncid);
526    IF (err)
527 error("nc_open: %s", nc_strerror(err));
528    for (i = 0; i < NDIMSi++) {
529 err = nc_inq_dimlen(BAD_IDi, &length);
530        IF (err != NC_EBADID)
531     error("bad ncid: status = %d", err);
532 err = nc_inq_dimlen(ncidBAD_DIMID, &length);
533        IF (err != NC_EBADDIM)
534     error("bad dimid: status = %d", err);
535 err = nc_inq_dimlen(ncidi, &length);
536 IF (err)
537     error("nc_inq_dimlen: %s", nc_strerror(err));
538 else IF (dim_len[i] != length)
539     error("size expected: %d, got: %d",dim_len[i],length);
540    }
541    err = nc_close(ncid);
542    IF (err)
543 error("nc_close: %s", nc_strerror(err));
544}
545
546
547void
548test_nc_inq_dimname(void)
549{
550    int ncid;
551    int i;
552    int err;
553    char name[NC_MAX_NAME];
554
555    err = file_open(testfileNC_NOWRITE, &ncid);
556    IF (err)
557 error("nc_open: %s", nc_strerror(err));
558    for (i = 0; i < NDIMSi++) {
559 err = nc_inq_dimname(BAD_IDiname);
560        IF (err != NC_EBADID)
561     error("bad ncid: status = %d", err);
562 err = nc_inq_dimname(ncidBAD_DIMIDname);
563        IF (err != NC_EBADDIM)
564     error("bad dimid: status = %d", err);
565 err = nc_inq_dimname(ncidiname);
566 IF (err)
567     error("nc_inq_dimname: %s", nc_strerror(err));
568 else IF (strcmp(dim_name[i],name))
569     error("name expected: %s, got: %s",dim_name[i],name);
570    }
571    err = nc_close(ncid);
572    IF (err)
573 error("nc_close: %s", nc_strerror(err));
574}
575
576
577void
578test_nc_inq_varid(void)
579{
580    int ncid;
581    int varid;
582    int i;
583    int err;
584
585    err = file_open(testfileNC_NOWRITE, &ncid);
586    IF (err)
587 error("nc_open: %s", nc_strerror(err));
588
589    err = nc_inq_varid(ncid, "noSuch", &varid);
590    IF (err != NC_ENOTVAR)
591 error("bad ncid: status = %d", err);
592
593    for (i = 0; i < numVarsi++) {
594 err = nc_inq_varid(BAD_IDvar_name[i], &varid);
595        IF (err != NC_EBADID)
596     error("bad ncid: status = %d", err);
597 err = nc_inq_varid(ncidvar_name[i], &varid);
598        IF (err)
599     error("nc_inq_varid: %s", nc_strerror(err));
600 else IF (varid != i)
601     error("expected %d, got %d", ivarid);
602    }
603
604    err = nc_close(ncid);
605    IF (err)
606 error("nc_close: %s", nc_strerror(err));
607}
608
609
610void
611test_nc_inq_var(void)
612{
613    int ncid;
614    int i;
615    int err;
616    char name[NC_MAX_NAME];
617    nc_type datatype;
618    int ndims;
619    int dimids[MAX_RANK];
620    int natts;
621
622    err = file_open(testfileNC_NOWRITE, &ncid);
623    IF (err)
624 error("nc_open: %s", nc_strerror(err));
625    for (i = 0; i < numVarsi++) {
626 err = nc_inq_var(BAD_IDiname, &datatype, &ndimsdimids, &natts);
627        IF (err != NC_EBADID)
628     error("bad ncid: status = %d", err);
629 err = nc_inq_var(ncid,BAD_VARID,name,&datatype,&ndims,dimids,&natts);
630        IF (err != NC_ENOTVAR)
631     error("bad var id: status = %d", err);
632 err = nc_inq_var(ncidi, 0, 0, 0, 0, 0);
633 IF (err)
634     error("nc_inq_var: %s", nc_strerror(err));
635 err = nc_inq_var(ncidiname, &datatype, &ndimsdimids, &natts);
636 IF (err)
637     error("nc_inq_var: %s", nc_strerror(err));
638 else IF (strcmp(var_name[i],name))
639     error("name expected: %s, got: %s",var_name[i],name);
640 else IF (var_type[i] != datatype)
641     error("type expected: %d, got: %d",var_type[i],datatype);
642 else IF (var_rank[i] != ndims)
643     error("ndims expected: %d, got: %d",var_rank[i],ndims);
644 else IF (!int_vec_eq(var_dimid[i],dimids,ndims))
645     error("unexpected dimid");
646 else IF (var_natts[i] != natts)
647     error("natts expected: %d, got: %d",var_natts[i],natts);
648 err = nc_inq_var(ncidiname, 0, 0, 0, 0);
649        IF (err)
650     error("nc_inq_var: %s", nc_strerror(err));
651 else IF (strcmp(var_name[i],name))
652     error("name expected: %s, got: %s",var_name[i],name);
653 err = nc_inq_var(ncidi, 0, &datatype, 0, 0, 0);
654        IF (err)
655     error("nc_inq_var: %s", nc_strerror(err));
656        else IF (var_type[i] != datatype)
657            error("type expected: %d, got: %d",var_type[i],datatype);
658 err = nc_inq_var(ncidi, 0, 0, &ndims, 0, 0);
659        IF (err)
660     error("nc_inq_var: %s", nc_strerror(err));
661        else IF (var_rank[i] != ndims)
662            error("ndims expected: %d, got: %d",var_rank[i],ndims);
663 err = nc_inq_var(ncidi, 0, 0, 0, dimids, 0);
664        IF (err)
665     error("nc_inq_var: %s", nc_strerror(err));
666        else IF (!int_vec_eq(var_dimid[i],dimids,ndims))
667            error("unexpected dimid");
668 err = nc_inq_var(ncidi, 0, 0, 0, 0, &natts);
669        IF (err)
670     error("nc_inq_var: %s", nc_strerror(err));
671        else IF (var_natts[i] != natts)
672            error("natts expected: %d, got: %d",var_natts[i],natts);
673    }
674    err = nc_close(ncid);
675    IF (err)
676 error("nc_close: %s", nc_strerror(err));
677}
678
679
680void
681test_nc_inq_vardimid(void)
682{
683    int ncid;
684    int i;
685    int err;
686    int dimids[MAX_RANK];
687
688    err = file_open(testfileNC_NOWRITE, &ncid);
689    IF (err)
690 error("nc_open: %s", nc_strerror(err));
691    for (i = 0; i < numVarsi++) {
692 err = nc_inq_vardimid(BAD_IDidimids);
693        IF (err != NC_EBADID)
694     error("bad ncid: status = %d", err);
695 err = nc_inq_vardimid(ncidBAD_VARIDdimids);
696        IF (err != NC_ENOTVAR)
697     error("bad var id: status = %d", err);
698 err = nc_inq_vardimid(ncididimids);
699 IF (err)
700     error("nc_inq_vardimid: %s", nc_strerror(err));
701 else IF (!int_vec_eq(var_dimid[i], dimidsvar_rank[i]))
702     error("unexpected dimid");
703    }
704    err = nc_close(ncid);
705    IF (err)
706 error("nc_close: %s", nc_strerror(err));
707}
708
709
710void
711test_nc_inq_varname(void)
712{
713    int ncid;
714    int i;
715    int err;
716    char name[NC_MAX_NAME];
717
718    err = file_open(testfileNC_NOWRITE, &ncid);
719    IF (err)
720 error("nc_open: %s", nc_strerror(err));
721    for (i = 0; i < numVarsi++) {
722 err = nc_inq_varname(BAD_IDiname);
723        IF (err != NC_EBADID)
724     error("bad ncid: status = %d", err);
725 err = nc_inq_varname(ncidBAD_VARIDname);
726        IF (err != NC_ENOTVAR)
727     error("bad var id: status = %d", err);
728 err = nc_inq_varname(ncidiname);
729 IF (err)
730     error("nc_inq_varname: %s", nc_strerror(err));
731 else IF (strcmp(var_name[i],name))
732     error("name expected: %s, got: %s",var_name[i],name);
733    }
734    err = nc_close(ncid);
735    IF (err)
736 error("nc_close: %s", nc_strerror(err));
737}
738
739
740void
741test_nc_inq_varnatts(void)
742{
743    int ncid;
744    int i;
745    int err;
746    int natts;
747
748    err = file_open(testfileNC_NOWRITE, &ncid);
749    IF (err)
750 error("nc_open: %s", nc_strerror(err));
751    for (i = -1; i < numVarsi++) {
752 err = nc_inq_varnatts(BAD_IDi, &natts);
753        IF (err != NC_EBADID)
754     error("bad ncid: status = %d", err);
755 err = nc_inq_varnatts(ncidBAD_VARID, &natts);
756        IF (err != NC_ENOTVAR)
757     error("bad var id: status = %d", err);
758 err = nc_inq_varnatts(ncidVARID(i), &natts);
759 IF (err)
760     error("nc_inq_varnatts: %s", nc_strerror(err));
761        else IF (NATTS(i) != natts)
762            error("natts expected: %d, got: %d",NATTS(i),natts);
763    }
764    err = nc_close(ncid);
765    IF (err)
766 error("nc_close: %s", nc_strerror(err));
767}
768
769
770void
771test_nc_inq_varndims(void)
772{
773    int ncid;
774    int i;
775    int err;
776    int ndims;
777
778    err = file_open(testfileNC_NOWRITE, &ncid);
779    IF (err)
780 error("nc_open: %s", nc_strerror(err));
781    for (i = 0; i < numVarsi++) {
782 err = nc_inq_varndims(BAD_IDi, &ndims);
783        IF (err != NC_EBADID)
784     error("bad ncid: status = %d", err);
785 err = nc_inq_varndims(ncidBAD_VARID, &ndims);
786        IF (err != NC_ENOTVAR)
787     error("bad var id: status = %d", err);
788 err = nc_inq_varndims(ncidi, &ndims);
789 IF (err)
790     error("nc_inq_varndims: %s", nc_strerror(err));
791        else IF (var_rank[i] != ndims)
792            error("ndims expected: %d, got: %d",var_rank[i],ndims);
793    }
794    err = nc_close(ncid);
795    IF (err)
796 error("nc_close: %s", nc_strerror(err));
797}
798
799
800void
801test_nc_inq_vartype(void)
802{
803    int ncid;
804    int i;
805    int err;
806    nc_type datatype;
807
808    err = file_open(testfileNC_NOWRITE, &ncid);
809    IF (err)
810 error("nc_open: %s", nc_strerror(err));
811    for (i = 0; i < numVarsi++) {
812 err = nc_inq_vartype(BAD_IDi, &datatype);
813        IF (err != NC_EBADID)
814     error("bad ncid: status = %d", err);
815 err = nc_inq_vartype(ncidBAD_VARID, &datatype);
816        IF (err != NC_ENOTVAR)
817     error("bad var id: status = %d", err);
818 err = nc_inq_vartype(ncidi, &datatype);
819 IF (err)
820     error("nc_inq_vartype: %s", nc_strerror(err));
821        else IF (var_type[i] != datatype)
822            error("type expected: %d, got: %d", var_type[i], datatype);
823    }
824    err = nc_close(ncid);
825    IF (err)
826 error("nc_close: %s", nc_strerror(err));
827}
828
829
830/*
831 * Test nc_put_var1
832 */
833void
834test_nc_get_var1(void)
835{
836    int ncid;
837    int i;
838    int j;
839    int err;
840    size_t index[MAX_RANK];
841    double expect;
842    int nok = 0; /* count of valid comparisons */
843    double buf[1]; /* (void *) buffer */
844    double value;
845
846    err = file_open(testfileNC_NOWRITE, &ncid);
847    IF (err)
848 error("nc_open: %s", nc_strerror(err));
849    for (i = 0; i < numVarsi++) {
850 for (j = 0; j < var_rank[i]; j++)
851     index[j] = 0;
852        err = nc_get_var1(BAD_IDiindexbuf);
853        IF (err != NC_EBADID)
854     error("bad ncid: status = %d", err);
855        err = nc_get_var1(ncidBAD_VARIDindexbuf);
856        IF (err != NC_ENOTVAR)
857     error("bad var id: status = %d", err);
858 for (j = 0; j < var_rank[i]; j++) {
859     index[j] = var_shape[i][j];
860     err = nc_get_var1(ncidiindexbuf);
861            IF (err != NC_EINVALCOORDS)
862                error("bad index: status = %d", err);
863     index[j] = 0;
864 }
865        for (j = 0; j < var_nels[i]; j++) {
866     err = toMixedBase(jvar_rank[i], var_shape[i], index);
867     IF (err)
868 error("error in toMixedBase 2");
869     expect = hashvar_type[i], var_rank[i], index );
870            if (var_rank[i] == 0 && i%2 )
871 err = nc_get_var1(ncidiNULLbuf);
872     else
873 err = nc_get_var1(ncidiindexbuf);
874     IF (err)
875 error("%s", nc_strerror(err));
876     err = nc2dblvar_type[i], buf, &value );
877     IF (err)
878 error("error in nc2dbl");
879     if (inRange(expect,var_type[i])) {
880 IF (!equal(value,expect,var_type[i],NCT_DOUBLE)) {
881     error("expected: %G, got: %G", expectvalue);
882 } else {
883     nok++;
884 }
885     }
886        }
887    }
888    err = nc_close(ncid);
889    IF (err)
890 error("nc_close: %s", nc_strerror(err));
891    print_nok(nok);
892}
893
894/*
895 * Test nc_get_vara
896 * Choose a random point dividing each dim into 2 parts
897 * Get 2^rank (nslabs) slabs so defined
898 * Each get overwrites buffer, so check after each get.
899 */
900void
901test_nc_get_vara(void)
902{
903    int ncid;
904    int d;
905    int i;
906    int j;
907    int k;
908    int err;
909    int nels;
910    int nslabs;
911    int nok = 0;      /* count of valid comparisons */
912    size_t start[MAX_RANK];
913    size_t edge[MAX_RANK];
914    size_t index[MAX_RANK];
915    size_t mid[MAX_RANK];
916    double buf[MAX_NELS]; /* (void *) buffer */
917    char *p; /* (void *) pointer */
918    double expect;
919    double got;
920
921    err = file_open(testfileNC_NOWRITE, &ncid);
922    IF (err)
923 error("nc_open: %s", nc_strerror(err));
924    for (i = 0; i < numVarsi++) {
925        assert(var_rank[i] <= MAX_RANK);
926        assert(var_nels[i] <= MAX_NELS);
927        for (j = 0; j < var_rank[i]; j++) {
928            start[j] = 0;
929            edge[j] = 1;
930        }
931        err = nc_get_vara(BAD_IDistartedgebuf);
932        IF (err != NC_EBADID)
933     error("bad ncid: status = %d", err);
934        err = nc_get_vara(ncidBAD_VARIDstartedgebuf);
935        IF (err != NC_ENOTVAR)
936     error("bad var id: status = %d", err);
937 for (j = 0; j < var_rank[i]; j++) {
938     start[j] = var_shape[i][j];
939     err = nc_get_vara(ncidistartedgebuf);
940            IF (err != NC_EINVALCOORDS)
941                error("bad index: status = %d", err);
942     start[j] = 0;
943     edge[j] = var_shape[i][j] + 1;
944     err = nc_get_vara(ncidistartedgebuf);
945            IF (err != NC_EEDGE)
946 error("bad edge: status = %d", err);
947     edge[j] = 1;
948 }
949            /* Choose a random point dividing each dim into 2 parts */
950            /* get 2^rank (nslabs) slabs so defined */
951        nslabs = 1;
952        for (j = 0; j < var_rank[i]; j++) {
953            mid[j] = rollvar_shape[i][j] );
954            nslabs *= 2;
955        }
956            /* bits of k determine whether to get lower or upper part of dim */
957        for (k = 0; k < nslabsk++) {
958            nels = 1;
959            for (j = 0; j < var_rank[i]; j++) {
960                if ((k >> j) & 1) {
961                    start[j] = 0;
962                    edge[j] = mid[j];
963                }else{
964                    start[j] = mid[j];
965                    edge[j] = var_shape[i][j] - mid[j];
966                }
967                nels *= edge[j];
968            }
969            if (var_rank[i] == 0 && i%2 )
970 err = nc_get_vara(ncidiNULLNULLbuf);
971     else
972 err = nc_get_vara(ncidistartedgebuf);
973     IF (err) {
974 error("%s", nc_strerror(err));
975     } else {
976 for (j = 0; j < nelsj++) {
977                    p = (char *) buf;
978                    p += j * nctypelen(var_type[i]);
979     err = nc2dblvar_type[i], p, & got );
980     IF (err)
981 error("error in nc2dbl");
982     err = toMixedBase(jvar_rank[i], edgeindex);
983     IF (err)
984 error("error in toMixedBase 1");
985     for (d = 0; d < var_rank[i]; d++)
986 index[d] += start[d];
987     expect = hash(var_type[i], var_rank[i], index);
988     if (inRange(expect,var_type[i])) {
989 IF (!equal(got,expect,var_type[i],NCT_DOUBLE)) {
990     error("value read not that expected");
991     if (verbose) {
992 error("\n");
993 error("varid: %d, ", i);
994 error("var_name: %s, ", var_name[i]);
995 error("element number: %d ", j);
996 error("expect: %g", expect);
997 error("got: %g", got);
998     }
999 } else {
1000     nok++;
1001 }
1002     }
1003 }
1004     }
1005 }
1006    }
1007    err = nc_close(ncid);
1008    IF (err)
1009        error("nc_close: %s", nc_strerror(err));
1010    print_nok(nok);
1011}
1012
1013
1014/*
1015 * Test nc_get_vars
1016 * Choose a random point dividing each dim into 2 parts
1017 * Get 2^rank (nslabs) slabs so defined
1018 * Each get overwrites buffer, so check after each get.
1019 */
1020void
1021test_nc_get_vars(void)
1022{
1023    int ncid;
1024    int d;
1025    int i;
1026    int j;
1027    int k;
1028    int m;
1029    int err;
1030    int nels;
1031    int nslabs;
1032    int nstarts; /* number of different starts */
1033    int nok = 0; /* total count of valid comparisons */
1034    int n; /* count of valid comparisons within var */
1035    size_t start[MAX_RANK];
1036    size_t edge[MAX_RANK];
1037    size_t index[MAX_RANK];
1038    size_t index2[MAX_RANK];
1039    size_t mid[MAX_RANK];
1040    size_t count[MAX_RANK];
1041    size_t sstride[MAX_RANK];
1042    ptrdiff_t stride[MAX_RANK];
1043    double buf[MAX_NELS];     /* (void *) buffer */
1044    char *p; /* (void *) pointer */
1045    double expect;
1046    double got;
1047
1048    err = file_open(testfileNC_NOWRITE, &ncid);
1049    IF (err)
1050 error("nc_open: %s", nc_strerror(err));
1051    for (i = 0; i < numVarsi++) {
1052        assert(var_rank[i] <= MAX_RANK);
1053        assert(var_nels[i] <= MAX_NELS);
1054        for (j = 0; j < var_rank[i]; j++) {
1055            start[j] = 0;
1056            edge[j] = 1;
1057            stride[j] = 1;
1058        }
1059        err = nc_get_vars(BAD_IDistartedgestridebuf);
1060        IF (err != NC_EBADID)
1061     error("bad ncid: status = %d", err);
1062        err = nc_get_vars(ncidBAD_VARIDstartedgestridebuf);
1063        IF (err != NC_ENOTVAR)
1064     error("bad var id: status = %d", err);
1065 for (j = 0; j < var_rank[i]; j++) {
1066     start[j] = var_shape[i][j];
1067     err = nc_get_vars(ncidistartedgestridebuf);
1068            IF (err != NC_EINVALCOORDS)
1069                error("bad index: status = %d", err);
1070     start[j] = 0;
1071     edge[j] = var_shape[i][j] + 1;
1072     err = nc_get_vars(ncidistartedgestridebuf);
1073            IF (err != NC_EEDGE)
1074 error("bad edge: status = %d", err);
1075     edge[j] = 1;
1076     stride[j] = 0;
1077     err = nc_get_vars(ncidistartedgestridebuf);
1078            IF (err != NC_ESTRIDE)
1079 error("bad stride: status = %d", err);
1080     stride[j] = 1;
1081 }
1082            /* Choose a random point dividing each dim into 2 parts */
1083            /* get 2^rank (nslabs) slabs so defined */
1084        nslabs = 1;
1085        for (j = 0; j < var_rank[i]; j++) {
1086            mid[j] = rollvar_shape[i][j] );
1087            nslabs *= 2;
1088        }
1089            /* bits of k determine whether to get lower or upper part of dim */
1090     /* choose random stride from 1 to edge */
1091 n = 0;
1092        for (k = 0; k < nslabsk++) {
1093            nstarts = 1;
1094            for (j = 0; j < var_rank[i]; j++) {
1095                if ((k >> j) & 1) {
1096                    start[j] = 0;
1097                    edge[j] = mid[j];
1098                }else{
1099                    start[j] = mid[j];
1100                    edge[j] = var_shape[i][j] - mid[j];
1101                }
1102 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
1103                nstarts *= stride[j];
1104            }
1105     for (m = 0; m < nstartsm++) {
1106 err = toMixedBase(mvar_rank[i], sstrideindex);
1107 IF (err)
1108     error("error in toMixedBase");
1109 nels = 1;
1110 for (j = 0; j < var_rank[i]; j++) {
1111     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
1112     nels *= count[j];
1113     index[j] += start[j];
1114 }
1115 /* Random choice of forward or backward */
1116/* TODO
1117 if ( roll(2) ) {
1118     for (j = 0; j < var_rank[i]; j++) {
1119 index[j] += (count[j] - 1) * stride[j];
1120 stride[j] = -stride[j];
1121     }
1122 }
1123 */
1124 if (var_rank[i] == 0 && i%2 )
1125     err = nc_get_vars(ncidiNULLNULLNULLbuf);
1126 else
1127     err = nc_get_vars(ncidiindexcountstridebuf);
1128 IF (err) {
1129     error("%s", nc_strerror(err));
1130 } else {
1131     for (j = 0; j < nelsj++) {
1132 p = (char *) buf;
1133 p += j * nctypelen(var_type[i]);
1134 err = nc2dblvar_type[i], p, & got );
1135 IF (err)
1136     error("error in nc2dbl");
1137 err = toMixedBase(jvar_rank[i], countindex2);
1138 IF (err)
1139     error("error in toMixedBase 1");
1140 for (d = 0; d < var_rank[i]; d++)
1141     index2[d] = index[d] + index2[d] * stride[d];
1142 expect = hash(var_type[i], var_rank[i], index2);
1143 if (inRange(expect,var_type[i])) {
1144     IF (!equal(got,expect,var_type[i],NCT_DOUBLE)) {
1145 error("value read not that expected");
1146 if (verbose) {
1147     error("\n");
1148     error("varid: %d, ", i);
1149     error("var_name: %s, ", var_name[i]);
1150     error("element number: %d ", j);
1151     error("expect: %g, ", expect);
1152     error("got: %g ", got);
1153 }
1154     } else {
1155 nok++;
1156     }
1157 }
1158 n++;
1159     }
1160 }
1161     }
1162 }
1163 IF (n != var_nels[i]) {
1164     error("count != nels");
1165     if (verbose) {
1166 error("\n");
1167 error("varid: %d, ", i);
1168 error("var_name: %s, ", var_name[i]);
1169 error("count: %d, ", n);
1170 error("nels: %d ", var_nels[i]);
1171     }
1172 }
1173    }
1174    err = nc_close(ncid);
1175    IF (err)
1176        error("nc_close: %s", nc_strerror(err));
1177    print_nok(nok);
1178}
1179
1180
1181/*
1182 * Test nc_get_varm
1183 * Choose a random point dividing each dim into 2 parts
1184 * Get 2^rank (nslabs) slabs so defined
1185 * Choose random stride from 1 to edge
1186 * Buffer should end up being bit image of external variable.
1187 * So all gets for a variable store in different elements of buffer
1188 */
1189void
1190test_nc_get_varm(void)
1191{
1192    int ncid;
1193    int i;
1194    int j;
1195    int k;
1196    int m;
1197    int err;
1198    int nslabs;
1199    int nstarts; /* number of different starts */
1200    int nok = 0; /* total count of valid comparisons */
1201    size_t start[MAX_RANK];
1202    size_t edge[MAX_RANK];
1203    size_t index[MAX_RANK];
1204    size_t mid[MAX_RANK];
1205    size_t count[MAX_RANK];
1206    size_t sstride[MAX_RANK];
1207    ptrdiff_t stride[MAX_RANK];
1208    ptrdiff_t imap[MAX_RANK];
1209    ptrdiff_t imap2[MAX_RANK];
1210    double buf[MAX_NELS]; /* (void *) buffer */
1211    char *p; /* (void *) pointer */
1212    double expect;
1213    double got;
1214
1215    err = file_open(testfileNC_NOWRITE, &ncid);
1216    IF (err)
1217 error("nc_open: %s", nc_strerror(err));
1218    for (i = 0; i < numVarsi++) {
1219        assert(var_rank[i] <= MAX_RANK);
1220        assert(var_nels[i] <= MAX_NELS);
1221        for (j = 0; j < var_rank[i]; j++) {
1222            start[j] = 0;
1223            edge[j] = 1;
1224            stride[j] = 1;
1225        }
1226        if (var_rank[i] > 0) {
1227            j = var_rank[i] - 1;
1228            /* imap[j] = nctypelen(var_type[i]); in bytes */
1229            imap[j] = 1; /* in numbers of elements */
1230            for (; j > 0; j--)
1231                imap[j-1] = imap[j] * var_shape[i][j];
1232        }
1233        err = nc_get_varm(BAD_IDistartedgestrideimapbuf);
1234        IF (err != NC_EBADID)
1235     error("bad ncid: status = %d", err);
1236        err = nc_get_varm(ncidBAD_VARIDstartedgestrideimapbuf);
1237        IF (err != NC_ENOTVAR)
1238     error("bad var id: status = %d", err);
1239 for (j = 0; j < var_rank[i]; j++) {
1240     start[j] = var_shape[i][j];
1241     err = nc_get_varm(ncidistartedgestrideimapbuf);
1242            IF (err != NC_EINVALCOORDS)
1243                error("bad index: status = %d", err);
1244     start[j] = 0;
1245     edge[j] = var_shape[i][j] + 1;
1246     err = nc_get_varm(ncidistartedgestrideimapbuf);
1247            IF (err != NC_EEDGE)
1248 error("bad edge: status = %d", err);
1249     edge[j] = 1;
1250     stride[j] = 0;
1251     err = nc_get_varm(ncidistartedgestrideimapbuf);
1252            IF (err != NC_ESTRIDE)
1253 error("bad stride: status = %d", err);
1254     stride[j] = 1;
1255 }
1256            /* Choose a random point dividing each dim into 2 parts */
1257            /* get 2^rank (nslabs) slabs so defined */
1258        nslabs = 1;
1259        for (j = 0; j < var_rank[i]; j++) {
1260            mid[j] = rollvar_shape[i][j] );
1261            nslabs *= 2;
1262        }
1263            /* bits of k determine whether to get lower or upper part of dim */
1264     /* choose random stride from 1 to edge */
1265        for (k = 0; k < nslabsk++) {
1266            nstarts = 1;
1267            for (j = 0; j < var_rank[i]; j++) {
1268                if ((k >> j) & 1) {
1269                    start[j] = 0;
1270                    edge[j] = mid[j];
1271                }else{
1272                    start[j] = mid[j];
1273                    edge[j] = var_shape[i][j] - mid[j];
1274                }
1275 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
1276 imap2[j] = imap[j] * sstride[j];
1277                nstarts *= stride[j];
1278            }
1279     for (m = 0; m < nstartsm++) {
1280 if (var_rank[i] == 0 && i%2 ) {
1281     err = nc_get_varm(ncidiNULLNULLNULLNULLbuf);
1282 } else {
1283     err = toMixedBase(mvar_rank[i], sstrideindex);
1284     IF (err)
1285 error("error in toMixedBase");
1286     for (j = 0; j < var_rank[i]; j++) {
1287 count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
1288 index[j] += start[j];
1289     }
1290     /* Random choice of forward or backward */
1291/* TODO
1292     if ( roll(2) ) {
1293 for (j = 0; j < var_rank[i]; j++) {
1294     index[j] += (count[j] - 1) * stride[j];
1295     stride[j] = -stride[j];
1296 }
1297     }
1298 */
1299     j = fromMixedBase(var_rank[i], indexvar_shape[i]);
1300     p = (char *) buf + j * nctypelen(var_type[i]);
1301     err = nc_get_varm(ncidiindexcountstrideimap2p);
1302 }
1303 IF (err)
1304     error("%s", nc_strerror(err));
1305     }
1306 }
1307        p = (char *) buf;
1308 for (j = 0; j < var_nels[i]; j++) {
1309            err = toMixedBase(jvar_rank[i], var_shape[i], index);
1310            IF (err)
1311                error("error in toMixedBase");
1312            expect = hashvar_type[i], var_rank[i], index);
1313     err = nc2dblvar_type[i], p, & got );
1314     IF (err)
1315 error("error in nc2dbl");
1316     if (inRange(expect,var_type[i])) {
1317 IF (!equal(got,expect,var_type[i],NCT_DOUBLE)) {
1318     error("value read not that expected");
1319     if (verbose) {
1320 error("\n");
1321 error("varid: %d, ", i);
1322 error("var_name: %s, ", var_name[i]);
1323 error("element number: %d ", j);
1324 error("expect: %g, ", expect);
1325 error("got: %g ", got);
1326     }
1327 } else {
1328     nok++;
1329 }
1330     }
1331            p += nctypelen(var_type[i]);
1332 }
1333    }
1334    err = nc_close(ncid);
1335    IF (err)
1336        error("nc_close: %s", nc_strerror(err));
1337    print_nok(nok);
1338}
1339
1340
1341void
1342test_nc_get_att(void)
1343{
1344    int ncid;
1345    int i;
1346    int j;
1347    size_t k;
1348    int err;
1349    double buf[MAX_NELS]; /* (void *) buffer */
1350    signed char *p; /* (void *) pointer */
1351    double expect;
1352    double got;
1353    int nok = 0;      /* count of valid comparisons */
1354
1355    err = file_open(testfileNC_NOWRITE, &ncid);
1356    IF (err)
1357 error("nc_open: %s", nc_strerror(err));
1358
1359    for (i = -1; i < numVarsi++) {
1360        for (j = 0; j < NATTS(i); j++) {
1361     err = nc_get_att(BAD_IDiATT_NAME(i,j), buf);
1362     IF (err != NC_EBADID)
1363 error("bad ncid: status = %d", err);
1364     err = nc_get_att(ncidBAD_VARIDATT_NAME(i,j), buf);
1365     IF (err != NC_ENOTVAR)
1366 error("bad var id: status = %d", err);
1367     err = nc_get_att(ncidi, "noSuch", buf);
1368     IF (err != NC_ENOTATT)
1369 error("Bad attribute name: status = %d", err);
1370     err = nc_get_att(ncidiATT_NAME(i,j), buf);
1371     IF (err) {
1372 error("%s", nc_strerror(err));
1373     } else {
1374 for (k = 0; k < ATT_LEN(i,j); k++) {
1375     expect = hash(ATT_TYPE(i,j), -1, &k );
1376     p = (signed char *) buf;
1377     p += k * nctypelen(ATT_TYPE(i,j));
1378     err = nc2dblATT_TYPE(i,j), p, &got );
1379     IF (err)
1380 error("error in nc2dbl");
1381     if (inRange(expect,ATT_TYPE(i,j))) {
1382              IF (!equal(got,expect,ATT_TYPE(i,j),NCT_DOUBLE)) {
1383     error("value read not that expected");
1384     if (verbose) {
1385 error("\n");
1386 error("varid: %d, ", i);
1387 error("var_name: %s, ",
1388 i >= 0 ? var_name[i] : "Global");
1389 error("att_name: %s, ", ATT_NAME(i,j));
1390 error("element number: %d\n", k);
1391 error("expect: %-23.16e\n", expect);
1392 error("   got: %-23.16e", got);
1393     }
1394 } else {
1395     nok++;
1396 }
1397     }
1398                }
1399     }
1400 }
1401    }
1402
1403    err = nc_close(ncid);
1404    IF (err)
1405 error("nc_close: %s", nc_strerror(err));
1406    print_nok(nok);
1407}
1408
1409
1410void
1411test_nc_inq_att(void)
1412{
1413    int ncid;
1414    int i;
1415    int j;
1416    int err;
1417    nc_type t;
1418    size_t n;
1419
1420    err = file_open(testfileNC_NOWRITE, &ncid);
1421    IF (err)
1422 error("nc_open: %s", nc_strerror(err));
1423
1424    for (i = -1; i < numVarsi++) {
1425        for (j = 0; j < NATTS(i); j++) {
1426     err = nc_inq_att(BAD_IDiATT_NAME(i,j), &t, &n);
1427     IF (err != NC_EBADID)
1428 error("bad ncid: status = %d", err);
1429     err = nc_inq_att(ncidBAD_VARIDATT_NAME(i,j), &t, &n);
1430     IF (err != NC_ENOTVAR)
1431 error("bad var id: status = %d", err);
1432     err = nc_inq_att(ncidi, "noSuch", &t, &n);
1433     IF (err != NC_ENOTATT)
1434 error("Bad attribute name: status = %d", err);
1435     err = nc_inq_att(ncidiATT_NAME(i,j), &t, &n);
1436     IF (err) {
1437 error("%s", nc_strerror(err));
1438     } else {
1439 IF (t != ATT_TYPE(i,j))
1440     error("type not that expected");
1441 IF (n != ATT_LEN(i,j))
1442     error("length not that expected");
1443     }
1444 }
1445    }
1446
1447    err = nc_close(ncid);
1448    IF (err)
1449 error("nc_close: %s", nc_strerror(err));
1450}
1451
1452
1453void
1454test_nc_inq_attlen(void)
1455{
1456    int ncid;
1457    int i;
1458    int j;
1459    int err;
1460    size_t len;
1461
1462    err = file_open(testfileNC_NOWRITE, &ncid);
1463    IF (err)
1464        error("nc_open: %s", nc_strerror(err));
1465
1466    for (i = -1; i < numVarsi++) {
1467 err = nc_inq_attlen(ncidi, "noSuch", &len);
1468 IF (err != NC_ENOTATT)
1469     error("Bad attribute name: status = %d", err);
1470        for (j = 0; j < NATTS(i); j++) {
1471            err = nc_inq_attlen(BAD_IDiATT_NAME(i,j), &len);
1472            IF (err != NC_EBADID)
1473                error("bad ncid: status = %d", err);
1474            err = nc_inq_attlen(ncidBAD_VARIDATT_NAME(i,j), &len);
1475            IF (err != NC_ENOTVAR)
1476                error("bad varid: status = %d", err);
1477            err = nc_inq_attlen(ncidiATT_NAME(i,j), &len);
1478            IF (err) {
1479                error("%s", nc_strerror(err));
1480            } else {
1481 IF (len != ATT_LEN(i,j))
1482     error("len not that expected");
1483            }
1484        }
1485    }
1486
1487    err = nc_close(ncid);
1488    IF (err)
1489 error("nc_close: %s", nc_strerror(err));
1490}
1491
1492
1493void
1494test_nc_inq_atttype(void)
1495{
1496    int ncid;
1497    int i;
1498    int j;
1499    int err;
1500    nc_type datatype;
1501
1502    err = file_open(testfileNC_NOWRITE, &ncid);
1503    IF (err)
1504        error("nc_open: %s", nc_strerror(err));
1505
1506    for (i = -1; i < numVarsi++) {
1507 err = nc_inq_atttype(ncidi, "noSuch", &datatype);
1508 IF (err != NC_ENOTATT)
1509     error("Bad attribute name: status = %d", err);
1510        for (j = 0; j < NATTS(i); j++) {
1511            err = nc_inq_atttype(BAD_IDiATT_NAME(i,j), &datatype);
1512            IF (err != NC_EBADID)
1513                error("bad ncid: status = %d", err);
1514            err = nc_inq_atttype(ncidBAD_VARIDATT_NAME(i,j), &datatype);
1515            IF (err != NC_ENOTVAR)
1516                error("bad varid: status = %d", err);
1517            err = nc_inq_atttype(ncidiATT_NAME(i,j), &datatype);
1518            IF (err) {
1519                error("%s", nc_strerror(err));
1520            } else {
1521 IF (datatype != ATT_TYPE(i,j))
1522     error("type not that expected");
1523            }
1524        }
1525    }
1526
1527    err = nc_close(ncid);
1528    IF (err)
1529 error("nc_close: %s", nc_strerror(err));
1530}
1531
1532
1533void
1534test_nc_inq_attname(void)
1535{
1536    int ncid;
1537    int i;
1538    int j;
1539    int err;
1540    char name[NC_MAX_NAME];
1541
1542    err = file_open(testfileNC_NOWRITE, &ncid);
1543    IF (err)
1544        error("nc_open: %s", nc_strerror(err));
1545
1546    for (i = -1; i < numVarsi++) {
1547 err = nc_inq_attname(ncidiBAD_ATTNUMname);
1548 IF (err != NC_ENOTATT)
1549     error("Bad attribute number: status = %d", err);
1550 err = nc_inq_attname(ncidiNATTS(i), name);
1551 IF (err != NC_ENOTATT)
1552     error("Bad attribute number: status = %d", err);
1553        for (j = 0; j < NATTS(i); j++) {
1554            err = nc_inq_attname(BAD_IDijname);
1555            IF (err != NC_EBADID)
1556                error("bad ncid: status = %d", err);
1557            err = nc_inq_attname(ncidBAD_VARIDjname);
1558            IF (err != NC_ENOTVAR)
1559                error("bad var id: status = %d", err);
1560            err = nc_inq_attname(ncidijname);
1561            IF (err) {
1562                error("%s", nc_strerror(err));
1563            } else {
1564 IF (strcmp(ATT_NAME(i,j), name) != 0)
1565     error("name not that expected");
1566            }
1567        }
1568    }
1569
1570    err = nc_close(ncid);
1571    IF (err)
1572 error("nc_close: %s", nc_strerror(err));
1573}
1574
1575
1576void
1577test_nc_inq_attid(void)
1578{
1579    int ncid;
1580    int i;
1581    int j;
1582    int err;
1583    int attnum;
1584
1585    err = file_open(testfileNC_NOWRITE, &ncid);
1586    IF (err)
1587        error("nc_open: %s", nc_strerror(err));
1588
1589    for (i = -1; i < numVarsi++) {
1590 err = nc_inq_attid(ncidi, "noSuch", &attnum);
1591 IF (err != NC_ENOTATT)
1592     error("Bad attribute name: status = %d", err);
1593        for (j = 0; j < NATTS(i); j++) {
1594            err = nc_inq_attid(BAD_IDiATT_NAME(i,j), &attnum);
1595            IF (err != NC_EBADID)
1596                error("bad ncid: status = %d", err);
1597            err = nc_inq_attid(ncidBAD_VARIDATT_NAME(i,j), &attnum);
1598            IF (err != NC_ENOTVAR)
1599                error("bad varid: status = %d", err);
1600            err = nc_inq_attid(ncidiATT_NAME(i,j), &attnum);
1601            IF (err) {
1602                error("%s", nc_strerror(err));
1603            } else {
1604 IF (attnum != j)
1605     error("attnum not that expected");
1606            }
1607        }
1608    }
1609
1610    err = nc_close(ncid);
1611    IF (err)
1612 error("nc_close: %s", nc_strerror(err));
1613}


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed