1/* Do not edit this file. It is produced from the corresponding .m4 source */
2/*********************************************************************
3 *   Copyright 1996, UCAR/Unidata
4 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
5 *   $Id: test_put.m4 2785 2014-10-26 05:21:20Z wkliao $
6 *********************************************************************/
7
8#ifdef USE_PARALLEL
9#include <mpi.h>
10#endif
11
12
13#include "tests.h"
14
15
16/*
17 *  ensure hash value within range for internal TYPE
18 */
19static
20double
21hash_text(
22    const nc_type type,
23    const int rank,
24    const size_t *index,
25    const nct_itype itype)
26{
27    const double min = text_min;
28    const double max = text_max;
29
30    return MAX(minMIN(maxhash4typerankindexitype)));
31}
32
33/*
34 *  ensure hash value within range for internal TYPE
35 */
36static
37double
38hash_uchar(
39    const nc_type type,
40    const int rank,
41    const size_t *index,
42    const nct_itype itype)
43{
44    const double min = uchar_min;
45    const double max = uchar_max;
46
47    return MAX(minMIN(maxhash4typerankindexitype)));
48}
49
50/*
51 *  ensure hash value within range for internal TYPE
52 */
53static
54double
55hash_schar(
56    const nc_type type,
57    const int rank,
58    const size_t *index,
59    const nct_itype itype)
60{
61    const double min = schar_min;
62    const double max = schar_max;
63
64    return MAX(minMIN(maxhash4typerankindexitype)));
65}
66
67/*
68 *  ensure hash value within range for internal TYPE
69 */
70static
71double
72hash_short(
73    const nc_type type,
74    const int rank,
75    const size_t *index,
76    const nct_itype itype)
77{
78    const double min = short_min;
79    const double max = short_max;
80
81    return MAX(minMIN(maxhash4typerankindexitype)));
82}
83
84/*
85 *  ensure hash value within range for internal TYPE
86 */
87static
88double
89hash_int(
90    const nc_type type,
91    const int rank,
92    const size_t *index,
93    const nct_itype itype)
94{
95    const double min = int_min;
96    const double max = int_max;
97
98    return MAX(minMIN(maxhash4typerankindexitype)));
99}
100
101/*
102 *  ensure hash value within range for internal TYPE
103 */
104static
105double
106hash_long(
107    const nc_type type,
108    const int rank,
109    const size_t *index,
110    const nct_itype itype)
111{
112    const double min = long_min;
113    const double max = long_max;
114
115    return MAX(minMIN(maxhash4typerankindexitype)));
116}
117
118/*
119 *  ensure hash value within range for internal TYPE
120 */
121static
122double
123hash_float(
124    const nc_type type,
125    const int rank,
126    const size_t *index,
127    const nct_itype itype)
128{
129    const double min = float_min;
130    const double max = float_max;
131
132    return MAX(minMIN(maxhash4typerankindexitype)));
133}
134
135/*
136 *  ensure hash value within range for internal TYPE
137 */
138static
139double
140hash_double(
141    const nc_type type,
142    const int rank,
143    const size_t *index,
144    const nct_itype itype)
145{
146    const double min = double_min;
147    const double max = double_max;
148
149    return MAX(minMIN(maxhash4typerankindexitype)));
150}
151
152/*
153 *  ensure hash value within range for internal TYPE
154 */
155static
156double
157hash_ushort(
158    const nc_type type,
159    const int rank,
160    const size_t *index,
161    const nct_itype itype)
162{
163    const double min = ushort_min;
164    const double max = ushort_max;
165
166    return MAX(minMIN(maxhash4typerankindexitype)));
167}
168
169/*
170 *  ensure hash value within range for internal TYPE
171 */
172static
173double
174hash_uint(
175    const nc_type type,
176    const int rank,
177    const size_t *index,
178    const nct_itype itype)
179{
180    const double min = uint_min;
181    const double max = uint_max;
182
183    return MAX(minMIN(maxhash4typerankindexitype)));
184}
185
186/*
187 *  ensure hash value within range for internal TYPE
188 */
189static
190double
191hash_longlong(
192    const nc_type type,
193    const int rank,
194    const size_t *index,
195    const nct_itype itype)
196{
197    const double min = longlong_min;
198    const double max = longlong_max;
199
200    return MAX(minMIN(maxhash4typerankindexitype)));
201}
202
203/*
204 *  ensure hash value within range for internal TYPE
205 */
206static
207double
208hash_ulonglong(
209    const nc_type type,
210    const int rank,
211    const size_t *index,
212    const nct_itype itype)
213{
214    const double min = ulonglong_min;
215    const double max = ulonglong_max;
216
217    return MAX(minMIN(maxhash4typerankindexitype)));
218}
219
220
221
222
223/*
224 *  check all vars in file which are (text/numeric) compatible with TYPE
225 */
226static
227void
228check_vars_text(const char *filename)
229{
230    int  ncid;                  /* netCDF id */
231    size_t index[MAX_RANK];
232    int  err;           /* status */
233    int  d;
234    int  i;
235    size_t  j;
236    text value;
237    nc_type datatype;
238    int ndims;
239    int dimids[MAX_RANK];
240    double expect;
241    char name[NC_MAX_NAME];
242    size_t length;
243    int canConvert;     /* Both text or both numeric */
244    int nok = 0;      /* count of valid comparisons */
245
246    err = file_open(filenameNC_NOWRITE, &ncid);
247    IF (err)
248        error("nc_open: %s", nc_strerror(err));
249
250    for (i = 0; i < numVarsi++) {
251 canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
252 if (canConvert) {
253     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
254     IF (err)
255 error("nc_inq_var: %s", nc_strerror(err));
256     IF (strcmp(namevar_name[i]) != 0)
257 error("Unexpected var_name");
258     IF (datatype != var_type[i])
259 error("Unexpected type");
260     IF (ndims != var_rank[i])
261 error("Unexpected rank");
262     for (j = 0; j < ndimsj++) {
263 err = nc_inq_dim(nciddimids[j], 0, &length);
264 IF (err)
265     error("nc_inq_dim: %s", nc_strerror(err));
266 IF (length != var_shape[i][j])
267     error("Unexpected shape");
268     }
269     for (j = 0; j < var_nels[i]; j++) {
270 err = toMixedBase(jvar_rank[i], var_shape[i], index);
271 IF (err)
272     error("error in toMixedBase 2");
273 expect = hash4var_type[i], var_rank[i], indexNCT_TEXT);
274 err = nc_get_var1_text(ncidiindex, &value);
275 if (inRange3(expect,datatype,NCT_TEXT)) {
276                    if (expect >= text_min && expect <= text_max) {
277 IF (err) {
278     error("nc_get_var1_text: %s", nc_strerror(err));
279 } else {
280                            IF (!equal(value,expect,var_type[i],NCT_TEXT)) {
281 error("Var value read not that expected");
282 if (verbose) {
283     error("\n");
284     error("varid: %d, ", i);
285     error("var_name: %s, ", var_name[i]);
286     error("index:");
287     for (d = 0; d < var_rank[i]; d++)
288 error(" %d", index[d]);
289     error(", expect: %g, ", expect);
290     error("got: %g", (double) value);
291 }
292     } else {
293 ++nok;
294     }
295 }
296     }
297 }
298     }
299 }
300    }
301    err = nc_close (ncid);
302    IF (err)
303        error("nc_close: %s", nc_strerror(err));
304    print_nok(nok);
305}
306
307/*
308 *  check all vars in file which are (text/numeric) compatible with TYPE
309 */
310static
311void
312check_vars_uchar(const char *filename)
313{
314    int  ncid;                  /* netCDF id */
315    size_t index[MAX_RANK];
316    int  err;           /* status */
317    int  d;
318    int  i;
319    size_t  j;
320    uchar value;
321    nc_type datatype;
322    int ndims;
323    int dimids[MAX_RANK];
324    double expect;
325    char name[NC_MAX_NAME];
326    size_t length;
327    int canConvert;     /* Both text or both numeric */
328    int nok = 0;      /* count of valid comparisons */
329
330    err = file_open(filenameNC_NOWRITE, &ncid);
331    IF (err)
332        error("nc_open: %s", nc_strerror(err));
333
334    for (i = 0; i < numVarsi++) {
335 canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
336 if (canConvert) {
337     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
338     IF (err)
339 error("nc_inq_var: %s", nc_strerror(err));
340     IF (strcmp(namevar_name[i]) != 0)
341 error("Unexpected var_name");
342     IF (datatype != var_type[i])
343 error("Unexpected type");
344     IF (ndims != var_rank[i])
345 error("Unexpected rank");
346     for (j = 0; j < ndimsj++) {
347 err = nc_inq_dim(nciddimids[j], 0, &length);
348 IF (err)
349     error("nc_inq_dim: %s", nc_strerror(err));
350 IF (length != var_shape[i][j])
351     error("Unexpected shape");
352     }
353     for (j = 0; j < var_nels[i]; j++) {
354 err = toMixedBase(jvar_rank[i], var_shape[i], index);
355 IF (err)
356     error("error in toMixedBase 2");
357 expect = hash4var_type[i], var_rank[i], indexNCT_UCHAR);
358 err = nc_get_var1_uchar(ncidiindex, &value);
359 if (inRange3(expect,datatype,NCT_UCHAR)) {
360                    if (expect >= uchar_min && expect <= uchar_max) {
361 IF (err) {
362     error("nc_get_var1_uchar: %s", nc_strerror(err));
363 } else {
364                            IF (!equal(value,expect,var_type[i],NCT_UCHAR)) {
365 error("Var value read not that expected");
366 if (verbose) {
367     error("\n");
368     error("varid: %d, ", i);
369     error("var_name: %s, ", var_name[i]);
370     error("index:");
371     for (d = 0; d < var_rank[i]; d++)
372 error(" %d", index[d]);
373     error(", expect: %g, ", expect);
374     error("got: %g", (double) value);
375 }
376     } else {
377 ++nok;
378     }
379 }
380     }
381 }
382     }
383 }
384    }
385    err = nc_close (ncid);
386    IF (err)
387        error("nc_close: %s", nc_strerror(err));
388    print_nok(nok);
389}
390
391/*
392 *  check all vars in file which are (text/numeric) compatible with TYPE
393 */
394static
395void
396check_vars_schar(const char *filename)
397{
398    int  ncid;                  /* netCDF id */
399    size_t index[MAX_RANK];
400    int  err;           /* status */
401    int  d;
402    int  i;
403    size_t  j;
404    schar value;
405    nc_type datatype;
406    int ndims;
407    int dimids[MAX_RANK];
408    double expect;
409    char name[NC_MAX_NAME];
410    size_t length;
411    int canConvert;     /* Both text or both numeric */
412    int nok = 0;      /* count of valid comparisons */
413
414    err = file_open(filenameNC_NOWRITE, &ncid);
415    IF (err)
416        error("nc_open: %s", nc_strerror(err));
417
418    for (i = 0; i < numVarsi++) {
419 canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
420 if (canConvert) {
421     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
422     IF (err)
423 error("nc_inq_var: %s", nc_strerror(err));
424     IF (strcmp(namevar_name[i]) != 0)
425 error("Unexpected var_name");
426     IF (datatype != var_type[i])
427 error("Unexpected type");
428     IF (ndims != var_rank[i])
429 error("Unexpected rank");
430     for (j = 0; j < ndimsj++) {
431 err = nc_inq_dim(nciddimids[j], 0, &length);
432 IF (err)
433     error("nc_inq_dim: %s", nc_strerror(err));
434 IF (length != var_shape[i][j])
435     error("Unexpected shape");
436     }
437     for (j = 0; j < var_nels[i]; j++) {
438 err = toMixedBase(jvar_rank[i], var_shape[i], index);
439 IF (err)
440     error("error in toMixedBase 2");
441 expect = hash4var_type[i], var_rank[i], indexNCT_SCHAR);
442 err = nc_get_var1_schar(ncidiindex, &value);
443 if (inRange3(expect,datatype,NCT_SCHAR)) {
444                    if (expect >= schar_min && expect <= schar_max) {
445 IF (err) {
446     error("nc_get_var1_schar: %s", nc_strerror(err));
447 } else {
448                            IF (!equal(value,expect,var_type[i],NCT_SCHAR)) {
449 error("Var value read not that expected");
450 if (verbose) {
451     error("\n");
452     error("varid: %d, ", i);
453     error("var_name: %s, ", var_name[i]);
454     error("index:");
455     for (d = 0; d < var_rank[i]; d++)
456 error(" %d", index[d]);
457     error(", expect: %g, ", expect);
458     error("got: %g", (double) value);
459 }
460     } else {
461 ++nok;
462     }
463 }
464     }
465 }
466     }
467 }
468    }
469    err = nc_close (ncid);
470    IF (err)
471        error("nc_close: %s", nc_strerror(err));
472    print_nok(nok);
473}
474
475/*
476 *  check all vars in file which are (text/numeric) compatible with TYPE
477 */
478static
479void
480check_vars_short(const char *filename)
481{
482    int  ncid;                  /* netCDF id */
483    size_t index[MAX_RANK];
484    int  err;           /* status */
485    int  d;
486    int  i;
487    size_t  j;
488    short value;
489    nc_type datatype;
490    int ndims;
491    int dimids[MAX_RANK];
492    double expect;
493    char name[NC_MAX_NAME];
494    size_t length;
495    int canConvert;     /* Both text or both numeric */
496    int nok = 0;      /* count of valid comparisons */
497
498    err = file_open(filenameNC_NOWRITE, &ncid);
499    IF (err)
500        error("nc_open: %s", nc_strerror(err));
501
502    for (i = 0; i < numVarsi++) {
503 canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
504 if (canConvert) {
505     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
506     IF (err)
507 error("nc_inq_var: %s", nc_strerror(err));
508     IF (strcmp(namevar_name[i]) != 0)
509 error("Unexpected var_name");
510     IF (datatype != var_type[i])
511 error("Unexpected type");
512     IF (ndims != var_rank[i])
513 error("Unexpected rank");
514     for (j = 0; j < ndimsj++) {
515 err = nc_inq_dim(nciddimids[j], 0, &length);
516 IF (err)
517     error("nc_inq_dim: %s", nc_strerror(err));
518 IF (length != var_shape[i][j])
519     error("Unexpected shape");
520     }
521     for (j = 0; j < var_nels[i]; j++) {
522 err = toMixedBase(jvar_rank[i], var_shape[i], index);
523 IF (err)
524     error("error in toMixedBase 2");
525 expect = hash4var_type[i], var_rank[i], indexNCT_SHORT);
526 err = nc_get_var1_short(ncidiindex, &value);
527 if (inRange3(expect,datatype,NCT_SHORT)) {
528                    if (expect >= short_min && expect <= short_max) {
529 IF (err) {
530     error("nc_get_var1_short: %s", nc_strerror(err));
531 } else {
532                            IF (!equal(value,expect,var_type[i],NCT_SHORT)) {
533 error("Var value read not that expected");
534 if (verbose) {
535     error("\n");
536     error("varid: %d, ", i);
537     error("var_name: %s, ", var_name[i]);
538     error("index:");
539     for (d = 0; d < var_rank[i]; d++)
540 error(" %d", index[d]);
541     error(", expect: %g, ", expect);
542     error("got: %g", (double) value);
543 }
544     } else {
545 ++nok;
546     }
547 }
548     }
549 }
550     }
551 }
552    }
553    err = nc_close (ncid);
554    IF (err)
555        error("nc_close: %s", nc_strerror(err));
556    print_nok(nok);
557}
558
559/*
560 *  check all vars in file which are (text/numeric) compatible with TYPE
561 */
562static
563void
564check_vars_int(const char *filename)
565{
566    int  ncid;                  /* netCDF id */
567    size_t index[MAX_RANK];
568    int  err;           /* status */
569    int  d;
570    int  i;
571    size_t  j;
572    int value;
573    nc_type datatype;
574    int ndims;
575    int dimids[MAX_RANK];
576    double expect;
577    char name[NC_MAX_NAME];
578    size_t length;
579    int canConvert;     /* Both text or both numeric */
580    int nok = 0;      /* count of valid comparisons */
581
582    err = file_open(filenameNC_NOWRITE, &ncid);
583    IF (err)
584        error("nc_open: %s", nc_strerror(err));
585
586    for (i = 0; i < numVarsi++) {
587 canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
588 if (canConvert) {
589     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
590     IF (err)
591 error("nc_inq_var: %s", nc_strerror(err));
592     IF (strcmp(namevar_name[i]) != 0)
593 error("Unexpected var_name");
594     IF (datatype != var_type[i])
595 error("Unexpected type");
596     IF (ndims != var_rank[i])
597 error("Unexpected rank");
598     for (j = 0; j < ndimsj++) {
599 err = nc_inq_dim(nciddimids[j], 0, &length);
600 IF (err)
601     error("nc_inq_dim: %s", nc_strerror(err));
602 IF (length != var_shape[i][j])
603     error("Unexpected shape");
604     }
605     for (j = 0; j < var_nels[i]; j++) {
606 err = toMixedBase(jvar_rank[i], var_shape[i], index);
607 IF (err)
608     error("error in toMixedBase 2");
609 expect = hash4var_type[i], var_rank[i], indexNCT_INT);
610 err = nc_get_var1_int(ncidiindex, &value);
611 if (inRange3(expect,datatype,NCT_INT)) {
612                    if (expect >= int_min && expect <= int_max) {
613 IF (err) {
614     error("nc_get_var1_int: %s", nc_strerror(err));
615 } else {
616                            IF (!equal(value,expect,var_type[i],NCT_INT)) {
617 error("Var value read not that expected");
618 if (verbose) {
619     error("\n");
620     error("varid: %d, ", i);
621     error("var_name: %s, ", var_name[i]);
622     error("index:");
623     for (d = 0; d < var_rank[i]; d++)
624 error(" %d", index[d]);
625     error(", expect: %g, ", expect);
626     error("got: %g", (double) value);
627 }
628     } else {
629 ++nok;
630     }
631 }
632     }
633 }
634     }
635 }
636    }
637    err = nc_close (ncid);
638    IF (err)
639        error("nc_close: %s", nc_strerror(err));
640    print_nok(nok);
641}
642
643/*
644 *  check all vars in file which are (text/numeric) compatible with TYPE
645 */
646static
647void
648check_vars_long(const char *filename)
649{
650    int  ncid;                  /* netCDF id */
651    size_t index[MAX_RANK];
652    int  err;           /* status */
653    int  d;
654    int  i;
655    size_t  j;
656    long value;
657    nc_type datatype;
658    int ndims;
659    int dimids[MAX_RANK];
660    double expect;
661    char name[NC_MAX_NAME];
662    size_t length;
663    int canConvert;     /* Both text or both numeric */
664    int nok = 0;      /* count of valid comparisons */
665
666    err = file_open(filenameNC_NOWRITE, &ncid);
667    IF (err)
668        error("nc_open: %s", nc_strerror(err));
669
670    for (i = 0; i < numVarsi++) {
671 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
672 if (canConvert) {
673     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
674     IF (err)
675 error("nc_inq_var: %s", nc_strerror(err));
676     IF (strcmp(namevar_name[i]) != 0)
677 error("Unexpected var_name");
678     IF (datatype != var_type[i])
679 error("Unexpected type");
680     IF (ndims != var_rank[i])
681 error("Unexpected rank");
682     for (j = 0; j < ndimsj++) {
683 err = nc_inq_dim(nciddimids[j], 0, &length);
684 IF (err)
685     error("nc_inq_dim: %s", nc_strerror(err));
686 IF (length != var_shape[i][j])
687     error("Unexpected shape");
688     }
689     for (j = 0; j < var_nels[i]; j++) {
690 err = toMixedBase(jvar_rank[i], var_shape[i], index);
691 IF (err)
692     error("error in toMixedBase 2");
693 expect = hash4var_type[i], var_rank[i], indexNCT_LONG);
694 err = nc_get_var1_long(ncidiindex, &value);
695 if (inRange3(expect,datatype,NCT_LONG)) {
696                    if (expect >= long_min && expect <= long_max) {
697 IF (err) {
698     error("nc_get_var1_long: %s", nc_strerror(err));
699 } else {
700                            IF (!equal(value,expect,var_type[i],NCT_LONG)) {
701 error("Var value read not that expected");
702 if (verbose) {
703     error("\n");
704     error("varid: %d, ", i);
705     error("var_name: %s, ", var_name[i]);
706     error("index:");
707     for (d = 0; d < var_rank[i]; d++)
708 error(" %d", index[d]);
709     error(", expect: %g, ", expect);
710     error("got: %g", (double) value);
711 }
712     } else {
713 ++nok;
714     }
715 }
716     }
717 }
718     }
719 }
720    }
721    err = nc_close (ncid);
722    IF (err)
723        error("nc_close: %s", nc_strerror(err));
724    print_nok(nok);
725}
726
727/*
728 *  check all vars in file which are (text/numeric) compatible with TYPE
729 */
730static
731void
732check_vars_float(const char *filename)
733{
734    int  ncid;                  /* netCDF id */
735    size_t index[MAX_RANK];
736    int  err;           /* status */
737    int  d;
738    int  i;
739    size_t  j;
740    float value;
741    nc_type datatype;
742    int ndims;
743    int dimids[MAX_RANK];
744    double expect;
745    char name[NC_MAX_NAME];
746    size_t length;
747    int canConvert;     /* Both text or both numeric */
748    int nok = 0;      /* count of valid comparisons */
749
750    err = file_open(filenameNC_NOWRITE, &ncid);
751    IF (err)
752        error("nc_open: %s", nc_strerror(err));
753
754    for (i = 0; i < numVarsi++) {
755 canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
756 if (canConvert) {
757     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
758     IF (err)
759 error("nc_inq_var: %s", nc_strerror(err));
760     IF (strcmp(namevar_name[i]) != 0)
761 error("Unexpected var_name");
762     IF (datatype != var_type[i])
763 error("Unexpected type");
764     IF (ndims != var_rank[i])
765 error("Unexpected rank");
766     for (j = 0; j < ndimsj++) {
767 err = nc_inq_dim(nciddimids[j], 0, &length);
768 IF (err)
769     error("nc_inq_dim: %s", nc_strerror(err));
770 IF (length != var_shape[i][j])
771     error("Unexpected shape");
772     }
773     for (j = 0; j < var_nels[i]; j++) {
774 err = toMixedBase(jvar_rank[i], var_shape[i], index);
775 IF (err)
776     error("error in toMixedBase 2");
777 expect = hash4var_type[i], var_rank[i], indexNCT_FLOAT);
778 err = nc_get_var1_float(ncidiindex, &value);
779 if (inRange3(expect,datatype,NCT_FLOAT)) {
780                    if (expect >= float_min && expect <= float_max) {
781 IF (err) {
782     error("nc_get_var1_float: %s", nc_strerror(err));
783 } else {
784                            IF (!equal(value,expect,var_type[i],NCT_FLOAT)) {
785 error("Var value read not that expected");
786 if (verbose) {
787     error("\n");
788     error("varid: %d, ", i);
789     error("var_name: %s, ", var_name[i]);
790     error("index:");
791     for (d = 0; d < var_rank[i]; d++)
792 error(" %d", index[d]);
793     error(", expect: %g, ", expect);
794     error("got: %g", (double) value);
795 }
796     } else {
797 ++nok;
798     }
799 }
800     }
801 }
802     }
803 }
804    }
805    err = nc_close (ncid);
806    IF (err)
807        error("nc_close: %s", nc_strerror(err));
808    print_nok(nok);
809}
810
811/*
812 *  check all vars in file which are (text/numeric) compatible with TYPE
813 */
814static
815void
816check_vars_double(const char *filename)
817{
818    int  ncid;                  /* netCDF id */
819    size_t index[MAX_RANK];
820    int  err;           /* status */
821    int  d;
822    int  i;
823    size_t  j;
824    double value;
825    nc_type datatype;
826    int ndims;
827    int dimids[MAX_RANK];
828    double expect;
829    char name[NC_MAX_NAME];
830    size_t length;
831    int canConvert;     /* Both text or both numeric */
832    int nok = 0;      /* count of valid comparisons */
833
834    err = file_open(filenameNC_NOWRITE, &ncid);
835    IF (err)
836        error("nc_open: %s", nc_strerror(err));
837
838    for (i = 0; i < numVarsi++) {
839 canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
840 if (canConvert) {
841     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
842     IF (err)
843 error("nc_inq_var: %s", nc_strerror(err));
844     IF (strcmp(namevar_name[i]) != 0)
845 error("Unexpected var_name");
846     IF (datatype != var_type[i])
847 error("Unexpected type");
848     IF (ndims != var_rank[i])
849 error("Unexpected rank");
850     for (j = 0; j < ndimsj++) {
851 err = nc_inq_dim(nciddimids[j], 0, &length);
852 IF (err)
853     error("nc_inq_dim: %s", nc_strerror(err));
854 IF (length != var_shape[i][j])
855     error("Unexpected shape");
856     }
857     for (j = 0; j < var_nels[i]; j++) {
858 err = toMixedBase(jvar_rank[i], var_shape[i], index);
859 IF (err)
860     error("error in toMixedBase 2");
861 expect = hash4var_type[i], var_rank[i], indexNCT_DOUBLE);
862 err = nc_get_var1_double(ncidiindex, &value);
863 if (inRange3(expect,datatype,NCT_DOUBLE)) {
864                    if (expect >= double_min && expect <= double_max) {
865 IF (err) {
866     error("nc_get_var1_double: %s", nc_strerror(err));
867 } else {
868                            IF (!equal(value,expect,var_type[i],NCT_DOUBLE)) {
869 error("Var value read not that expected");
870 if (verbose) {
871     error("\n");
872     error("varid: %d, ", i);
873     error("var_name: %s, ", var_name[i]);
874     error("index:");
875     for (d = 0; d < var_rank[i]; d++)
876 error(" %d", index[d]);
877     error(", expect: %g, ", expect);
878     error("got: %g", (double) value);
879 }
880     } else {
881 ++nok;
882     }
883 }
884     }
885 }
886     }
887 }
888    }
889    err = nc_close (ncid);
890    IF (err)
891        error("nc_close: %s", nc_strerror(err));
892    print_nok(nok);
893}
894
895/*
896 *  check all vars in file which are (text/numeric) compatible with TYPE
897 */
898static
899void
900check_vars_ushort(const char *filename)
901{
902    int  ncid;                  /* netCDF id */
903    size_t index[MAX_RANK];
904    int  err;           /* status */
905    int  d;
906    int  i;
907    size_t  j;
908    ushort value;
909    nc_type datatype;
910    int ndims;
911    int dimids[MAX_RANK];
912    double expect;
913    char name[NC_MAX_NAME];
914    size_t length;
915    int canConvert;     /* Both text or both numeric */
916    int nok = 0;      /* count of valid comparisons */
917
918    err = file_open(filenameNC_NOWRITE, &ncid);
919    IF (err)
920        error("nc_open: %s", nc_strerror(err));
921
922    for (i = 0; i < numVarsi++) {
923 canConvert = (var_type[i] == NC_CHAR) == (NCT_USHORT == NCT_TEXT);
924 if (canConvert) {
925     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
926     IF (err)
927 error("nc_inq_var: %s", nc_strerror(err));
928     IF (strcmp(namevar_name[i]) != 0)
929 error("Unexpected var_name");
930     IF (datatype != var_type[i])
931 error("Unexpected type");
932     IF (ndims != var_rank[i])
933 error("Unexpected rank");
934     for (j = 0; j < ndimsj++) {
935 err = nc_inq_dim(nciddimids[j], 0, &length);
936 IF (err)
937     error("nc_inq_dim: %s", nc_strerror(err));
938 IF (length != var_shape[i][j])
939     error("Unexpected shape");
940     }
941     for (j = 0; j < var_nels[i]; j++) {
942 err = toMixedBase(jvar_rank[i], var_shape[i], index);
943 IF (err)
944     error("error in toMixedBase 2");
945 expect = hash4var_type[i], var_rank[i], indexNCT_USHORT);
946 err = nc_get_var1_ushort(ncidiindex, &value);
947 if (inRange3(expect,datatype,NCT_USHORT)) {
948                    if (expect >= ushort_min && expect <= ushort_max) {
949 IF (err) {
950     error("nc_get_var1_ushort: %s", nc_strerror(err));
951 } else {
952                            IF (!equal(value,expect,var_type[i],NCT_USHORT)) {
953 error("Var value read not that expected");
954 if (verbose) {
955     error("\n");
956     error("varid: %d, ", i);
957     error("var_name: %s, ", var_name[i]);
958     error("index:");
959     for (d = 0; d < var_rank[i]; d++)
960 error(" %d", index[d]);
961     error(", expect: %g, ", expect);
962     error("got: %g", (double) value);
963 }
964     } else {
965 ++nok;
966     }
967 }
968     }
969 }
970     }
971 }
972    }
973    err = nc_close (ncid);
974    IF (err)
975        error("nc_close: %s", nc_strerror(err));
976    print_nok(nok);
977}
978
979/*
980 *  check all vars in file which are (text/numeric) compatible with TYPE
981 */
982static
983void
984check_vars_uint(const char *filename)
985{
986    int  ncid;                  /* netCDF id */
987    size_t index[MAX_RANK];
988    int  err;           /* status */
989    int  d;
990    int  i;
991    size_t  j;
992    uint value;
993    nc_type datatype;
994    int ndims;
995    int dimids[MAX_RANK];
996    double expect;
997    char name[NC_MAX_NAME];
998    size_t length;
999    int canConvert;     /* Both text or both numeric */
1000    int nok = 0;      /* count of valid comparisons */
1001
1002    err = file_open(filenameNC_NOWRITE, &ncid);
1003    IF (err)
1004        error("nc_open: %s", nc_strerror(err));
1005
1006    for (i = 0; i < numVarsi++) {
1007 canConvert = (var_type[i] == NC_CHAR) == (NCT_UINT == NCT_TEXT);
1008 if (canConvert) {
1009     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
1010     IF (err)
1011 error("nc_inq_var: %s", nc_strerror(err));
1012     IF (strcmp(namevar_name[i]) != 0)
1013 error("Unexpected var_name");
1014     IF (datatype != var_type[i])
1015 error("Unexpected type");
1016     IF (ndims != var_rank[i])
1017 error("Unexpected rank");
1018     for (j = 0; j < ndimsj++) {
1019 err = nc_inq_dim(nciddimids[j], 0, &length);
1020 IF (err)
1021     error("nc_inq_dim: %s", nc_strerror(err));
1022 IF (length != var_shape[i][j])
1023     error("Unexpected shape");
1024     }
1025     for (j = 0; j < var_nels[i]; j++) {
1026 err = toMixedBase(jvar_rank[i], var_shape[i], index);
1027 IF (err)
1028     error("error in toMixedBase 2");
1029 expect = hash4var_type[i], var_rank[i], indexNCT_UINT);
1030 err = nc_get_var1_uint(ncidiindex, &value);
1031 if (inRange3(expect,datatype,NCT_UINT)) {
1032                    if (expect >= uint_min && expect <= uint_max) {
1033 IF (err) {
1034     error("nc_get_var1_uint: %s", nc_strerror(err));
1035 } else {
1036                            IF (!equal(value,expect,var_type[i],NCT_UINT)) {
1037 error("Var value read not that expected");
1038 if (verbose) {
1039     error("\n");
1040     error("varid: %d, ", i);
1041     error("var_name: %s, ", var_name[i]);
1042     error("index:");
1043     for (d = 0; d < var_rank[i]; d++)
1044 error(" %d", index[d]);
1045     error(", expect: %g, ", expect);
1046     error("got: %g", (double) value);
1047 }
1048     } else {
1049 ++nok;
1050     }
1051 }
1052     }
1053 }
1054     }
1055 }
1056    }
1057    err = nc_close (ncid);
1058    IF (err)
1059        error("nc_close: %s", nc_strerror(err));
1060    print_nok(nok);
1061}
1062
1063/*
1064 *  check all vars in file which are (text/numeric) compatible with TYPE
1065 */
1066static
1067void
1068check_vars_longlong(const char *filename)
1069{
1070    int  ncid;                  /* netCDF id */
1071    size_t index[MAX_RANK];
1072    int  err;           /* status */
1073    int  d;
1074    int  i;
1075    size_t  j;
1076    longlong value;
1077    nc_type datatype;
1078    int ndims;
1079    int dimids[MAX_RANK];
1080    double expect;
1081    char name[NC_MAX_NAME];
1082    size_t length;
1083    int canConvert;     /* Both text or both numeric */
1084    int nok = 0;      /* count of valid comparisons */
1085
1086    err = file_open(filenameNC_NOWRITE, &ncid);
1087    IF (err)
1088        error("nc_open: %s", nc_strerror(err));
1089
1090    for (i = 0; i < numVarsi++) {
1091 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONGLONG == NCT_TEXT);
1092 if (canConvert) {
1093     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
1094     IF (err)
1095 error("nc_inq_var: %s", nc_strerror(err));
1096     IF (strcmp(namevar_name[i]) != 0)
1097 error("Unexpected var_name");
1098     IF (datatype != var_type[i])
1099 error("Unexpected type");
1100     IF (ndims != var_rank[i])
1101 error("Unexpected rank");
1102     for (j = 0; j < ndimsj++) {
1103 err = nc_inq_dim(nciddimids[j], 0, &length);
1104 IF (err)
1105     error("nc_inq_dim: %s", nc_strerror(err));
1106 IF (length != var_shape[i][j])
1107     error("Unexpected shape");
1108     }
1109     for (j = 0; j < var_nels[i]; j++) {
1110 err = toMixedBase(jvar_rank[i], var_shape[i], index);
1111 IF (err)
1112     error("error in toMixedBase 2");
1113 expect = hash4var_type[i], var_rank[i], indexNCT_LONGLONG);
1114 err = nc_get_var1_longlong(ncidiindex, &value);
1115 if (inRange3(expect,datatype,NCT_LONGLONG)) {
1116                    if (expect >= longlong_min && expect <= longlong_max) {
1117 IF (err) {
1118     error("nc_get_var1_longlong: %s", nc_strerror(err));
1119 } else {
1120                            IF (!equal(value,expect,var_type[i],NCT_LONGLONG)) {
1121 error("Var value read not that expected");
1122 if (verbose) {
1123     error("\n");
1124     error("varid: %d, ", i);
1125     error("var_name: %s, ", var_name[i]);
1126     error("index:");
1127     for (d = 0; d < var_rank[i]; d++)
1128 error(" %d", index[d]);
1129     error(", expect: %g, ", expect);
1130     error("got: %g", (double) value);
1131 }
1132     } else {
1133 ++nok;
1134     }
1135 }
1136     }
1137 }
1138     }
1139 }
1140    }
1141    err = nc_close (ncid);
1142    IF (err)
1143        error("nc_close: %s", nc_strerror(err));
1144    print_nok(nok);
1145}
1146
1147/*
1148 *  check all vars in file which are (text/numeric) compatible with TYPE
1149 */
1150static
1151void
1152check_vars_ulonglong(const char *filename)
1153{
1154    int  ncid;                  /* netCDF id */
1155    size_t index[MAX_RANK];
1156    int  err;           /* status */
1157    int  d;
1158    int  i;
1159    size_t  j;
1160    ulonglong value;
1161    nc_type datatype;
1162    int ndims;
1163    int dimids[MAX_RANK];
1164    double expect;
1165    char name[NC_MAX_NAME];
1166    size_t length;
1167    int canConvert;     /* Both text or both numeric */
1168    int nok = 0;      /* count of valid comparisons */
1169
1170    err = file_open(filenameNC_NOWRITE, &ncid);
1171    IF (err)
1172        error("nc_open: %s", nc_strerror(err));
1173
1174    for (i = 0; i < numVarsi++) {
1175 canConvert = (var_type[i] == NC_CHAR) == (NCT_ULONGLONG == NCT_TEXT);
1176 if (canConvert) {
1177     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
1178     IF (err)
1179 error("nc_inq_var: %s", nc_strerror(err));
1180     IF (strcmp(namevar_name[i]) != 0)
1181 error("Unexpected var_name");
1182     IF (datatype != var_type[i])
1183 error("Unexpected type");
1184     IF (ndims != var_rank[i])
1185 error("Unexpected rank");
1186     for (j = 0; j < ndimsj++) {
1187 err = nc_inq_dim(nciddimids[j], 0, &length);
1188 IF (err)
1189     error("nc_inq_dim: %s", nc_strerror(err));
1190 IF (length != var_shape[i][j])
1191     error("Unexpected shape");
1192     }
1193     for (j = 0; j < var_nels[i]; j++) {
1194 err = toMixedBase(jvar_rank[i], var_shape[i], index);
1195 IF (err)
1196     error("error in toMixedBase 2");
1197 expect = hash4var_type[i], var_rank[i], indexNCT_ULONGLONG);
1198 err = nc_get_var1_ulonglong(ncidiindex, &value);
1199 if (inRange3(expect,datatype,NCT_ULONGLONG)) {
1200                    if (expect >= ulonglong_min && expect <= ulonglong_max) {
1201 IF (err) {
1202     error("nc_get_var1_ulonglong: %s", nc_strerror(err));
1203 } else {
1204                            IF (!equal(value,expect,var_type[i],NCT_ULONGLONG)) {
1205 error("Var value read not that expected");
1206 if (verbose) {
1207     error("\n");
1208     error("varid: %d, ", i);
1209     error("var_name: %s, ", var_name[i]);
1210     error("index:");
1211     for (d = 0; d < var_rank[i]; d++)
1212 error(" %d", index[d]);
1213     error(", expect: %g, ", expect);
1214     error("got: %g", (double) value);
1215 }
1216     } else {
1217 ++nok;
1218     }
1219 }
1220     }
1221 }
1222     }
1223 }
1224    }
1225    err = nc_close (ncid);
1226    IF (err)
1227        error("nc_close: %s", nc_strerror(err));
1228    print_nok(nok);
1229}
1230
1231
1232
1233
1234/*
1235 *  check all attributes in file which are (text/numeric) compatible with TYPE
1236 *  ignore any attributes containing values outside range of TYPE
1237 */
1238static
1239void
1240check_atts_text(int  ncid)
1241{
1242    int  err;           /* status */
1243    int  i;
1244    int  j;
1245    size_t  k;
1246    text value[MAX_NELS];
1247    nc_type datatype;
1248    double expect[MAX_NELS];
1249    size_t length;
1250    size_t nInExtRange;  /* number values within external range */
1251    size_t nInIntRange;  /* number values within internal range */
1252    int canConvert;     /* Both text or both numeric */
1253    int nok = 0;      /* count of valid comparisons */
1254
1255    for (i = -1; i < numVarsi++) {
1256        for (j = 0; j < NATTS(i); j++) {
1257     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
1258     if (canConvert) {
1259 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1260 IF (err)
1261     error("nc_inq_att: %s", nc_strerror(err));
1262 IF (datatype != ATT_TYPE(i,j))
1263 error("nc_inq_att: unexpected type");
1264 IF (length != ATT_LEN(i,j))
1265     error("nc_inq_att: unexpected length");
1266 assert(length <= MAX_NELS);
1267 nInIntRange = nInExtRange = 0;
1268 for (k = 0; k < lengthk++) {
1269     expect[k] = hash4datatype, -1, &kNCT_TEXT);
1270     if (inRange3(expect[k], datatypeNCT_TEXT)) {
1271 ++nInExtRange;
1272 if (expect[k] >= text_min && expect[k] <= text_max)
1273     ++nInIntRange;
1274     }
1275 }
1276 err = nc_get_att_text(ncidiATT_NAME(i,j), value);
1277                if (nInExtRange == length && nInIntRange == length) {
1278     IF (err)
1279 error("%s", nc_strerror(err));
1280                } else {
1281                    IF (err != 0 && err != NC_ERANGE)
1282                        error("OK or Range error: status = %d", err);
1283                }
1284 for (k = 0; k < lengthk++) {
1285                    if (inRange3(expect[k],datatype,NCT_TEXT)
1286                            && expect[k] >= text_min && expect[k] <= text_max) {
1287                        IF (!equal(value[k],expect[k],datatype,NCT_TEXT)) {
1288                            error("att. value read not that expected");
1289                            if (verbose) {
1290                                error("\n");
1291                                error("varid: %d, ", i);
1292                                error("att_name: %s, ", ATT_NAME(i,j));
1293                                error("element number: %d ", k);
1294                                error("expect: %g, ", expect[k]);
1295                                error("got: %g", (double) value[k]);
1296                            }
1297                        } else {
1298                            nok++;
1299                        }
1300                    }
1301                }
1302            }
1303        }
1304    }
1305
1306    print_nok(nok);
1307}
1308
1309/*
1310 *  check all attributes in file which are (text/numeric) compatible with TYPE
1311 *  ignore any attributes containing values outside range of TYPE
1312 */
1313static
1314void
1315check_atts_uchar(int  ncid)
1316{
1317    int  err;           /* status */
1318    int  i;
1319    int  j;
1320    size_t  k;
1321    uchar value[MAX_NELS];
1322    nc_type datatype;
1323    double expect[MAX_NELS];
1324    size_t length;
1325    size_t nInExtRange;  /* number values within external range */
1326    size_t nInIntRange;  /* number values within internal range */
1327    int canConvert;     /* Both text or both numeric */
1328    int nok = 0;      /* count of valid comparisons */
1329
1330    for (i = -1; i < numVarsi++) {
1331        for (j = 0; j < NATTS(i); j++) {
1332     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
1333     if (canConvert) {
1334 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1335 IF (err)
1336     error("nc_inq_att: %s", nc_strerror(err));
1337 IF (datatype != ATT_TYPE(i,j))
1338 error("nc_inq_att: unexpected type");
1339 IF (length != ATT_LEN(i,j))
1340     error("nc_inq_att: unexpected length");
1341 assert(length <= MAX_NELS);
1342 nInIntRange = nInExtRange = 0;
1343 for (k = 0; k < lengthk++) {
1344     expect[k] = hash4datatype, -1, &kNCT_UCHAR);
1345     if (inRange3(expect[k], datatypeNCT_UCHAR)) {
1346 ++nInExtRange;
1347 if (expect[k] >= uchar_min && expect[k] <= uchar_max)
1348     ++nInIntRange;
1349     }
1350 }
1351 err = nc_get_att_uchar(ncidiATT_NAME(i,j), value);
1352                if (nInExtRange == length && nInIntRange == length) {
1353     IF (err)
1354 error("%s", nc_strerror(err));
1355                } else {
1356                    IF (err != 0 && err != NC_ERANGE)
1357                        error("OK or Range error: status = %d", err);
1358                }
1359 for (k = 0; k < lengthk++) {
1360                    if (inRange3(expect[k],datatype,NCT_UCHAR)
1361                            && expect[k] >= uchar_min && expect[k] <= uchar_max) {
1362                        IF (!equal(value[k],expect[k],datatype,NCT_UCHAR)) {
1363                            error("att. value read not that expected");
1364                            if (verbose) {
1365                                error("\n");
1366                                error("varid: %d, ", i);
1367                                error("att_name: %s, ", ATT_NAME(i,j));
1368                                error("element number: %d ", k);
1369                                error("expect: %g, ", expect[k]);
1370                                error("got: %g", (double) value[k]);
1371                            }
1372                        } else {
1373                            nok++;
1374                        }
1375                    }
1376                }
1377            }
1378        }
1379    }
1380
1381    print_nok(nok);
1382}
1383
1384/*
1385 *  check all attributes in file which are (text/numeric) compatible with TYPE
1386 *  ignore any attributes containing values outside range of TYPE
1387 */
1388static
1389void
1390check_atts_schar(int  ncid)
1391{
1392    int  err;           /* status */
1393    int  i;
1394    int  j;
1395    size_t  k;
1396    schar value[MAX_NELS];
1397    nc_type datatype;
1398    double expect[MAX_NELS];
1399    size_t length;
1400    size_t nInExtRange;  /* number values within external range */
1401    size_t nInIntRange;  /* number values within internal range */
1402    int canConvert;     /* Both text or both numeric */
1403    int nok = 0;      /* count of valid comparisons */
1404
1405    for (i = -1; i < numVarsi++) {
1406        for (j = 0; j < NATTS(i); j++) {
1407     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
1408     if (canConvert) {
1409 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1410 IF (err)
1411     error("nc_inq_att: %s", nc_strerror(err));
1412 IF (datatype != ATT_TYPE(i,j))
1413 error("nc_inq_att: unexpected type");
1414 IF (length != ATT_LEN(i,j))
1415     error("nc_inq_att: unexpected length");
1416 assert(length <= MAX_NELS);
1417 nInIntRange = nInExtRange = 0;
1418 for (k = 0; k < lengthk++) {
1419     expect[k] = hash4datatype, -1, &kNCT_SCHAR);
1420     if (inRange3(expect[k], datatypeNCT_SCHAR)) {
1421 ++nInExtRange;
1422 if (expect[k] >= schar_min && expect[k] <= schar_max)
1423     ++nInIntRange;
1424     }
1425 }
1426 err = nc_get_att_schar(ncidiATT_NAME(i,j), value);
1427                if (nInExtRange == length && nInIntRange == length) {
1428     IF (err)
1429 error("%s", nc_strerror(err));
1430                } else {
1431                    IF (err != 0 && err != NC_ERANGE)
1432                        error("OK or Range error: status = %d", err);
1433                }
1434 for (k = 0; k < lengthk++) {
1435                    if (inRange3(expect[k],datatype,NCT_SCHAR)
1436                            && expect[k] >= schar_min && expect[k] <= schar_max) {
1437                        IF (!equal(value[k],expect[k],datatype,NCT_SCHAR)) {
1438                            error("att. value read not that expected");
1439                            if (verbose) {
1440                                error("\n");
1441                                error("varid: %d, ", i);
1442                                error("att_name: %s, ", ATT_NAME(i,j));
1443                                error("element number: %d ", k);
1444                                error("expect: %g, ", expect[k]);
1445                                error("got: %g", (double) value[k]);
1446                            }
1447                        } else {
1448                            nok++;
1449                        }
1450                    }
1451                }
1452            }
1453        }
1454    }
1455
1456    print_nok(nok);
1457}
1458
1459/*
1460 *  check all attributes in file which are (text/numeric) compatible with TYPE
1461 *  ignore any attributes containing values outside range of TYPE
1462 */
1463static
1464void
1465check_atts_short(int  ncid)
1466{
1467    int  err;           /* status */
1468    int  i;
1469    int  j;
1470    size_t  k;
1471    short value[MAX_NELS];
1472    nc_type datatype;
1473    double expect[MAX_NELS];
1474    size_t length;
1475    size_t nInExtRange;  /* number values within external range */
1476    size_t nInIntRange;  /* number values within internal range */
1477    int canConvert;     /* Both text or both numeric */
1478    int nok = 0;      /* count of valid comparisons */
1479
1480    for (i = -1; i < numVarsi++) {
1481        for (j = 0; j < NATTS(i); j++) {
1482     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
1483     if (canConvert) {
1484 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1485 IF (err)
1486     error("nc_inq_att: %s", nc_strerror(err));
1487 IF (datatype != ATT_TYPE(i,j))
1488 error("nc_inq_att: unexpected type");
1489 IF (length != ATT_LEN(i,j))
1490     error("nc_inq_att: unexpected length");
1491 assert(length <= MAX_NELS);
1492 nInIntRange = nInExtRange = 0;
1493 for (k = 0; k < lengthk++) {
1494     expect[k] = hash4datatype, -1, &kNCT_SHORT);
1495     if (inRange3(expect[k], datatypeNCT_SHORT)) {
1496 ++nInExtRange;
1497 if (expect[k] >= short_min && expect[k] <= short_max)
1498     ++nInIntRange;
1499     }
1500 }
1501 err = nc_get_att_short(ncidiATT_NAME(i,j), value);
1502                if (nInExtRange == length && nInIntRange == length) {
1503     IF (err)
1504 error("%s", nc_strerror(err));
1505                } else {
1506                    IF (err != 0 && err != NC_ERANGE)
1507                        error("OK or Range error: status = %d", err);
1508                }
1509 for (k = 0; k < lengthk++) {
1510                    if (inRange3(expect[k],datatype,NCT_SHORT)
1511                            && expect[k] >= short_min && expect[k] <= short_max) {
1512                        IF (!equal(value[k],expect[k],datatype,NCT_SHORT)) {
1513                            error("att. value read not that expected");
1514                            if (verbose) {
1515                                error("\n");
1516                                error("varid: %d, ", i);
1517                                error("att_name: %s, ", ATT_NAME(i,j));
1518                                error("element number: %d ", k);
1519                                error("expect: %g, ", expect[k]);
1520                                error("got: %g", (double) value[k]);
1521                            }
1522                        } else {
1523                            nok++;
1524                        }
1525                    }
1526                }
1527            }
1528        }
1529    }
1530
1531    print_nok(nok);
1532}
1533
1534/*
1535 *  check all attributes in file which are (text/numeric) compatible with TYPE
1536 *  ignore any attributes containing values outside range of TYPE
1537 */
1538static
1539void
1540check_atts_int(int  ncid)
1541{
1542    int  err;           /* status */
1543    int  i;
1544    int  j;
1545    size_t  k;
1546    int value[MAX_NELS];
1547    nc_type datatype;
1548    double expect[MAX_NELS];
1549    size_t length;
1550    size_t nInExtRange;  /* number values within external range */
1551    size_t nInIntRange;  /* number values within internal range */
1552    int canConvert;     /* Both text or both numeric */
1553    int nok = 0;      /* count of valid comparisons */
1554
1555    for (i = -1; i < numVarsi++) {
1556        for (j = 0; j < NATTS(i); j++) {
1557     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_INT == NCT_TEXT);
1558     if (canConvert) {
1559 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1560 IF (err)
1561     error("nc_inq_att: %s", nc_strerror(err));
1562 IF (datatype != ATT_TYPE(i,j))
1563 error("nc_inq_att: unexpected type");
1564 IF (length != ATT_LEN(i,j))
1565     error("nc_inq_att: unexpected length");
1566 assert(length <= MAX_NELS);
1567 nInIntRange = nInExtRange = 0;
1568 for (k = 0; k < lengthk++) {
1569     expect[k] = hash4datatype, -1, &kNCT_INT);
1570     if (inRange3(expect[k], datatypeNCT_INT)) {
1571 ++nInExtRange;
1572 if (expect[k] >= int_min && expect[k] <= int_max)
1573     ++nInIntRange;
1574     }
1575 }
1576 err = nc_get_att_int(ncidiATT_NAME(i,j), value);
1577                if (nInExtRange == length && nInIntRange == length) {
1578     IF (err)
1579 error("%s", nc_strerror(err));
1580                } else {
1581                    IF (err != 0 && err != NC_ERANGE)
1582                        error("OK or Range error: status = %d", err);
1583                }
1584 for (k = 0; k < lengthk++) {
1585                    if (inRange3(expect[k],datatype,NCT_INT)
1586                            && expect[k] >= int_min && expect[k] <= int_max) {
1587                        IF (!equal(value[k],expect[k],datatype,NCT_INT)) {
1588                            error("att. value read not that expected");
1589                            if (verbose) {
1590                                error("\n");
1591                                error("varid: %d, ", i);
1592                                error("att_name: %s, ", ATT_NAME(i,j));
1593                                error("element number: %d ", k);
1594                                error("expect: %g, ", expect[k]);
1595                                error("got: %g", (double) value[k]);
1596                            }
1597                        } else {
1598                            nok++;
1599                        }
1600                    }
1601                }
1602            }
1603        }
1604    }
1605
1606    print_nok(nok);
1607}
1608
1609/*
1610 *  check all attributes in file which are (text/numeric) compatible with TYPE
1611 *  ignore any attributes containing values outside range of TYPE
1612 */
1613static
1614void
1615check_atts_long(int  ncid)
1616{
1617    int  err;           /* status */
1618    int  i;
1619    int  j;
1620    size_t  k;
1621    long value[MAX_NELS];
1622    nc_type datatype;
1623    double expect[MAX_NELS];
1624    size_t length;
1625    size_t nInExtRange;  /* number values within external range */
1626    size_t nInIntRange;  /* number values within internal range */
1627    int canConvert;     /* Both text or both numeric */
1628    int nok = 0;      /* count of valid comparisons */
1629
1630    for (i = -1; i < numVarsi++) {
1631        for (j = 0; j < NATTS(i); j++) {
1632     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_LONG == NCT_TEXT);
1633     if (canConvert) {
1634 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1635 IF (err)
1636     error("nc_inq_att: %s", nc_strerror(err));
1637 IF (datatype != ATT_TYPE(i,j))
1638 error("nc_inq_att: unexpected type");
1639 IF (length != ATT_LEN(i,j))
1640     error("nc_inq_att: unexpected length");
1641 assert(length <= MAX_NELS);
1642 nInIntRange = nInExtRange = 0;
1643 for (k = 0; k < lengthk++) {
1644     expect[k] = hash4datatype, -1, &kNCT_LONG);
1645     if (inRange3(expect[k], datatypeNCT_LONG)) {
1646 ++nInExtRange;
1647 if (expect[k] >= long_min && expect[k] <= long_max)
1648     ++nInIntRange;
1649     }
1650 }
1651 err = nc_get_att_long(ncidiATT_NAME(i,j), value);
1652                if (nInExtRange == length && nInIntRange == length) {
1653     IF (err)
1654 error("%s", nc_strerror(err));
1655                } else {
1656                    IF (err != 0 && err != NC_ERANGE)
1657                        error("OK or Range error: status = %d", err);
1658                }
1659 for (k = 0; k < lengthk++) {
1660                    if (inRange3(expect[k],datatype,NCT_LONG)
1661                            && expect[k] >= long_min && expect[k] <= long_max) {
1662                        IF (!equal(value[k],expect[k],datatype,NCT_LONG)) {
1663                            error("att. value read not that expected");
1664                            if (verbose) {
1665                                error("\n");
1666                                error("varid: %d, ", i);
1667                                error("att_name: %s, ", ATT_NAME(i,j));
1668                                error("element number: %d ", k);
1669                                error("expect: %g, ", expect[k]);
1670                                error("got: %g", (double) value[k]);
1671                            }
1672                        } else {
1673                            nok++;
1674                        }
1675                    }
1676                }
1677            }
1678        }
1679    }
1680
1681    print_nok(nok);
1682}
1683
1684/*
1685 *  check all attributes in file which are (text/numeric) compatible with TYPE
1686 *  ignore any attributes containing values outside range of TYPE
1687 */
1688static
1689void
1690check_atts_float(int  ncid)
1691{
1692    int  err;           /* status */
1693    int  i;
1694    int  j;
1695    size_t  k;
1696    float value[MAX_NELS];
1697    nc_type datatype;
1698    double expect[MAX_NELS];
1699    size_t length;
1700    size_t nInExtRange;  /* number values within external range */
1701    size_t nInIntRange;  /* number values within internal range */
1702    int canConvert;     /* Both text or both numeric */
1703    int nok = 0;      /* count of valid comparisons */
1704
1705    for (i = -1; i < numVarsi++) {
1706        for (j = 0; j < NATTS(i); j++) {
1707     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
1708     if (canConvert) {
1709 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1710 IF (err)
1711     error("nc_inq_att: %s", nc_strerror(err));
1712 IF (datatype != ATT_TYPE(i,j))
1713 error("nc_inq_att: unexpected type");
1714 IF (length != ATT_LEN(i,j))
1715     error("nc_inq_att: unexpected length");
1716 assert(length <= MAX_NELS);
1717 nInIntRange = nInExtRange = 0;
1718 for (k = 0; k < lengthk++) {
1719     expect[k] = hash4datatype, -1, &kNCT_FLOAT);
1720     if (inRange3(expect[k], datatypeNCT_FLOAT)) {
1721 ++nInExtRange;
1722 if (expect[k] >= float_min && expect[k] <= float_max)
1723     ++nInIntRange;
1724     }
1725 }
1726 err = nc_get_att_float(ncidiATT_NAME(i,j), value);
1727                if (nInExtRange == length && nInIntRange == length) {
1728     IF (err)
1729 error("%s", nc_strerror(err));
1730                } else {
1731                    IF (err != 0 && err != NC_ERANGE)
1732                        error("OK or Range error: status = %d", err);
1733                }
1734 for (k = 0; k < lengthk++) {
1735                    if (inRange3(expect[k],datatype,NCT_FLOAT)
1736                            && expect[k] >= float_min && expect[k] <= float_max) {
1737                        IF (!equal(value[k],expect[k],datatype,NCT_FLOAT)) {
1738                            error("att. value read not that expected");
1739                            if (verbose) {
1740                                error("\n");
1741                                error("varid: %d, ", i);
1742                                error("att_name: %s, ", ATT_NAME(i,j));
1743                                error("element number: %d ", k);
1744                                error("expect: %g, ", expect[k]);
1745                                error("got: %g", (double) value[k]);
1746                            }
1747                        } else {
1748                            nok++;
1749                        }
1750                    }
1751                }
1752            }
1753        }
1754    }
1755
1756    print_nok(nok);
1757}
1758
1759/*
1760 *  check all attributes in file which are (text/numeric) compatible with TYPE
1761 *  ignore any attributes containing values outside range of TYPE
1762 */
1763static
1764void
1765check_atts_double(int  ncid)
1766{
1767    int  err;           /* status */
1768    int  i;
1769    int  j;
1770    size_t  k;
1771    double value[MAX_NELS];
1772    nc_type datatype;
1773    double expect[MAX_NELS];
1774    size_t length;
1775    size_t nInExtRange;  /* number values within external range */
1776    size_t nInIntRange;  /* number values within internal range */
1777    int canConvert;     /* Both text or both numeric */
1778    int nok = 0;      /* count of valid comparisons */
1779
1780    for (i = -1; i < numVarsi++) {
1781        for (j = 0; j < NATTS(i); j++) {
1782     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
1783     if (canConvert) {
1784 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1785 IF (err)
1786     error("nc_inq_att: %s", nc_strerror(err));
1787 IF (datatype != ATT_TYPE(i,j))
1788 error("nc_inq_att: unexpected type");
1789 IF (length != ATT_LEN(i,j))
1790     error("nc_inq_att: unexpected length");
1791 assert(length <= MAX_NELS);
1792 nInIntRange = nInExtRange = 0;
1793 for (k = 0; k < lengthk++) {
1794     expect[k] = hash4datatype, -1, &kNCT_DOUBLE);
1795     if (inRange3(expect[k], datatypeNCT_DOUBLE)) {
1796 ++nInExtRange;
1797 if (expect[k] >= double_min && expect[k] <= double_max)
1798     ++nInIntRange;
1799     }
1800 }
1801 err = nc_get_att_double(ncidiATT_NAME(i,j), value);
1802                if (nInExtRange == length && nInIntRange == length) {
1803     IF (err)
1804 error("%s", nc_strerror(err));
1805                } else {
1806                    IF (err != 0 && err != NC_ERANGE)
1807                        error("OK or Range error: status = %d", err);
1808                }
1809 for (k = 0; k < lengthk++) {
1810                    if (inRange3(expect[k],datatype,NCT_DOUBLE)
1811                            && expect[k] >= double_min && expect[k] <= double_max) {
1812                        IF (!equal(value[k],expect[k],datatype,NCT_DOUBLE)) {
1813                            error("att. value read not that expected");
1814                            if (verbose) {
1815                                error("\n");
1816                                error("varid: %d, ", i);
1817                                error("att_name: %s, ", ATT_NAME(i,j));
1818                                error("element number: %d ", k);
1819                                error("expect: %g, ", expect[k]);
1820                                error("got: %g", (double) value[k]);
1821                            }
1822                        } else {
1823                            nok++;
1824                        }
1825                    }
1826                }
1827            }
1828        }
1829    }
1830
1831    print_nok(nok);
1832}
1833
1834/*
1835 *  check all attributes in file which are (text/numeric) compatible with TYPE
1836 *  ignore any attributes containing values outside range of TYPE
1837 */
1838static
1839void
1840check_atts_ushort(int  ncid)
1841{
1842    int  err;           /* status */
1843    int  i;
1844    int  j;
1845    size_t  k;
1846    ushort value[MAX_NELS];
1847    nc_type datatype;
1848    double expect[MAX_NELS];
1849    size_t length;
1850    size_t nInExtRange;  /* number values within external range */
1851    size_t nInIntRange;  /* number values within internal range */
1852    int canConvert;     /* Both text or both numeric */
1853    int nok = 0;      /* count of valid comparisons */
1854
1855    for (i = -1; i < numVarsi++) {
1856        for (j = 0; j < NATTS(i); j++) {
1857     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_USHORT == NCT_TEXT);
1858     if (canConvert) {
1859 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1860 IF (err)
1861     error("nc_inq_att: %s", nc_strerror(err));
1862 IF (datatype != ATT_TYPE(i,j))
1863 error("nc_inq_att: unexpected type");
1864 IF (length != ATT_LEN(i,j))
1865     error("nc_inq_att: unexpected length");
1866 assert(length <= MAX_NELS);
1867 nInIntRange = nInExtRange = 0;
1868 for (k = 0; k < lengthk++) {
1869     expect[k] = hash4datatype, -1, &kNCT_USHORT);
1870     if (inRange3(expect[k], datatypeNCT_USHORT)) {
1871 ++nInExtRange;
1872 if (expect[k] >= ushort_min && expect[k] <= ushort_max)
1873     ++nInIntRange;
1874     }
1875 }
1876 err = nc_get_att_ushort(ncidiATT_NAME(i,j), value);
1877                if (nInExtRange == length && nInIntRange == length) {
1878     IF (err)
1879 error("%s", nc_strerror(err));
1880                } else {
1881                    IF (err != 0 && err != NC_ERANGE)
1882                        error("OK or Range error: status = %d", err);
1883                }
1884 for (k = 0; k < lengthk++) {
1885                    if (inRange3(expect[k],datatype,NCT_USHORT)
1886                            && expect[k] >= ushort_min && expect[k] <= ushort_max) {
1887                        IF (!equal(value[k],expect[k],datatype,NCT_USHORT)) {
1888                            error("att. value read not that expected");
1889                            if (verbose) {
1890                                error("\n");
1891                                error("varid: %d, ", i);
1892                                error("att_name: %s, ", ATT_NAME(i,j));
1893                                error("element number: %d ", k);
1894                                error("expect: %g, ", expect[k]);
1895                                error("got: %g", (double) value[k]);
1896                            }
1897                        } else {
1898                            nok++;
1899                        }
1900                    }
1901                }
1902            }
1903        }
1904    }
1905
1906    print_nok(nok);
1907}
1908
1909/*
1910 *  check all attributes in file which are (text/numeric) compatible with TYPE
1911 *  ignore any attributes containing values outside range of TYPE
1912 */
1913static
1914void
1915check_atts_uint(int  ncid)
1916{
1917    int  err;           /* status */
1918    int  i;
1919    int  j;
1920    size_t  k;
1921    uint value[MAX_NELS];
1922    nc_type datatype;
1923    double expect[MAX_NELS];
1924    size_t length;
1925    size_t nInExtRange;  /* number values within external range */
1926    size_t nInIntRange;  /* number values within internal range */
1927    int canConvert;     /* Both text or both numeric */
1928    int nok = 0;      /* count of valid comparisons */
1929
1930    for (i = -1; i < numVarsi++) {
1931        for (j = 0; j < NATTS(i); j++) {
1932     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_UINT == NCT_TEXT);
1933     if (canConvert) {
1934 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
1935 IF (err)
1936     error("nc_inq_att: %s", nc_strerror(err));
1937 IF (datatype != ATT_TYPE(i,j))
1938 error("nc_inq_att: unexpected type");
1939 IF (length != ATT_LEN(i,j))
1940     error("nc_inq_att: unexpected length");
1941 assert(length <= MAX_NELS);
1942 nInIntRange = nInExtRange = 0;
1943 for (k = 0; k < lengthk++) {
1944     expect[k] = hash4datatype, -1, &kNCT_UINT);
1945     if (inRange3(expect[k], datatypeNCT_UINT)) {
1946 ++nInExtRange;
1947 if (expect[k] >= uint_min && expect[k] <= uint_max)
1948     ++nInIntRange;
1949     }
1950 }
1951 err = nc_get_att_uint(ncidiATT_NAME(i,j), value);
1952                if (nInExtRange == length && nInIntRange == length) {
1953     IF (err)
1954 error("%s", nc_strerror(err));
1955                } else {
1956                    IF (err != 0 && err != NC_ERANGE)
1957                        error("OK or Range error: status = %d", err);
1958                }
1959 for (k = 0; k < lengthk++) {
1960                    if (inRange3(expect[k],datatype,NCT_UINT)
1961                            && expect[k] >= uint_min && expect[k] <= uint_max) {
1962                        IF (!equal(value[k],expect[k],datatype,NCT_UINT)) {
1963                            error("att. value read not that expected");
1964                            if (verbose) {
1965                                error("\n");
1966                                error("varid: %d, ", i);
1967                                error("att_name: %s, ", ATT_NAME(i,j));
1968                                error("element number: %d ", k);
1969                                error("expect: %g, ", expect[k]);
1970                                error("got: %g", (double) value[k]);
1971                            }
1972                        } else {
1973                            nok++;
1974                        }
1975                    }
1976                }
1977            }
1978        }
1979    }
1980
1981    print_nok(nok);
1982}
1983
1984/*
1985 *  check all attributes in file which are (text/numeric) compatible with TYPE
1986 *  ignore any attributes containing values outside range of TYPE
1987 */
1988static
1989void
1990check_atts_longlong(int  ncid)
1991{
1992    int  err;           /* status */
1993    int  i;
1994    int  j;
1995    size_t  k;
1996    longlong value[MAX_NELS];
1997    nc_type datatype;
1998    double expect[MAX_NELS];
1999    size_t length;
2000    size_t nInExtRange;  /* number values within external range */
2001    size_t nInIntRange;  /* number values within internal range */
2002    int canConvert;     /* Both text or both numeric */
2003    int nok = 0;      /* count of valid comparisons */
2004
2005    for (i = -1; i < numVarsi++) {
2006        for (j = 0; j < NATTS(i); j++) {
2007     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_LONGLONG == NCT_TEXT);
2008     if (canConvert) {
2009 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
2010 IF (err)
2011     error("nc_inq_att: %s", nc_strerror(err));
2012 IF (datatype != ATT_TYPE(i,j))
2013 error("nc_inq_att: unexpected type");
2014 IF (length != ATT_LEN(i,j))
2015     error("nc_inq_att: unexpected length");
2016 assert(length <= MAX_NELS);
2017 nInIntRange = nInExtRange = 0;
2018 for (k = 0; k < lengthk++) {
2019     expect[k] = hash4datatype, -1, &kNCT_LONGLONG);
2020     if (inRange3(expect[k], datatypeNCT_LONGLONG)) {
2021 ++nInExtRange;
2022 if (expect[k] >= longlong_min && expect[k] <= longlong_max)
2023     ++nInIntRange;
2024     }
2025 }
2026 err = nc_get_att_longlong(ncidiATT_NAME(i,j), value);
2027                if (nInExtRange == length && nInIntRange == length) {
2028     IF (err)
2029 error("%s", nc_strerror(err));
2030                } else {
2031                    IF (err != 0 && err != NC_ERANGE)
2032                        error("OK or Range error: status = %d", err);
2033                }
2034 for (k = 0; k < lengthk++) {
2035                    if (inRange3(expect[k],datatype,NCT_LONGLONG)
2036                            && expect[k] >= longlong_min && expect[k] <= longlong_max) {
2037                        IF (!equal(value[k],expect[k],datatype,NCT_LONGLONG)) {
2038                            error("att. value read not that expected");
2039                            if (verbose) {
2040                                error("\n");
2041                                error("varid: %d, ", i);
2042                                error("att_name: %s, ", ATT_NAME(i,j));
2043                                error("element number: %d ", k);
2044                                error("expect: %g, ", expect[k]);
2045                                error("got: %g", (double) value[k]);
2046                            }
2047                        } else {
2048                            nok++;
2049                        }
2050                    }
2051                }
2052            }
2053        }
2054    }
2055
2056    print_nok(nok);
2057}
2058
2059/*
2060 *  check all attributes in file which are (text/numeric) compatible with TYPE
2061 *  ignore any attributes containing values outside range of TYPE
2062 */
2063static
2064void
2065check_atts_ulonglong(int  ncid)
2066{
2067    int  err;           /* status */
2068    int  i;
2069    int  j;
2070    size_t  k;
2071    ulonglong value[MAX_NELS];
2072    nc_type datatype;
2073    double expect[MAX_NELS];
2074    size_t length;
2075    size_t nInExtRange;  /* number values within external range */
2076    size_t nInIntRange;  /* number values within internal range */
2077    int canConvert;     /* Both text or both numeric */
2078    int nok = 0;      /* count of valid comparisons */
2079
2080    for (i = -1; i < numVarsi++) {
2081        for (j = 0; j < NATTS(i); j++) {
2082     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_ULONGLONG == NCT_TEXT);
2083     if (canConvert) {
2084 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
2085 IF (err)
2086     error("nc_inq_att: %s", nc_strerror(err));
2087 IF (datatype != ATT_TYPE(i,j))
2088 error("nc_inq_att: unexpected type");
2089 IF (length != ATT_LEN(i,j))
2090     error("nc_inq_att: unexpected length");
2091 assert(length <= MAX_NELS);
2092 nInIntRange = nInExtRange = 0;
2093 for (k = 0; k < lengthk++) {
2094     expect[k] = hash4datatype, -1, &kNCT_ULONGLONG);
2095     if (inRange3(expect[k], datatypeNCT_ULONGLONG)) {
2096 ++nInExtRange;
2097 if (expect[k] >= ulonglong_min && expect[k] <= ulonglong_max)
2098     ++nInIntRange;
2099     }
2100 }
2101 err = nc_get_att_ulonglong(ncidiATT_NAME(i,j), value);
2102                if (nInExtRange == length && nInIntRange == length) {
2103     IF (err)
2104 error("%s", nc_strerror(err));
2105                } else {
2106                    IF (err != 0 && err != NC_ERANGE)
2107                        error("OK or Range error: status = %d", err);
2108                }
2109 for (k = 0; k < lengthk++) {
2110                    if (inRange3(expect[k],datatype,NCT_ULONGLONG)
2111                            && expect[k] >= ulonglong_min && expect[k] <= ulonglong_max) {
2112                        IF (!equal(value[k],expect[k],datatype,NCT_ULONGLONG)) {
2113                            error("att. value read not that expected");
2114                            if (verbose) {
2115                                error("\n");
2116                                error("varid: %d, ", i);
2117                                error("att_name: %s, ", ATT_NAME(i,j));
2118                                error("element number: %d ", k);
2119                                error("expect: %g, ", expect[k]);
2120                                error("got: %g", (double) value[k]);
2121                            }
2122                        } else {
2123                            nok++;
2124                        }
2125                    }
2126                }
2127            }
2128        }
2129    }
2130
2131    print_nok(nok);
2132}
2133
2134
2135
2136
2137void
2138test_nc_put_var1_text(void)
2139{
2140    int ncid;
2141    int i;
2142    int j;
2143    int err;
2144    size_t index[MAX_RANK];
2145    int canConvert; /* Both text or both numeric */
2146    text value = 5; /* any value would do - only for error cases */
2147
2148    err = file_create(scratchNC_CLOBBER, &ncid);
2149    IF (err) {
2150        error("nc_create: %s", nc_strerror(err));
2151        return;
2152    }
2153    def_dims(ncid);
2154    def_vars(ncid);
2155    err = nc_enddef(ncid);
2156    IF (err)
2157        error("nc_enddef: %s", nc_strerror(err));
2158
2159#ifdef USE_PNETCDF
2160    {
2161    int format;
2162    nc_inq_format_extended(ncid, &formatNULL);
2163    if (format == NC_FORMATX_PNETCDF) {
2164        for (i = 0; i < numVarsi++) {
2165            err = nc_var_par_access(ncidiNC_COLLECTIVE);
2166     IF (err)
2167         error("nc_var_par_access: %s", nc_strerror(err));
2168        }
2169    }
2170    }
2171#endif
2172
2173    for (i = 0; i < numVarsi++) {
2174 canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
2175        for (j = 0; j < var_rank[i]; j++)
2176            index[j] = 0;
2177        err = nc_put_var1_text(BAD_IDiindex, &value);
2178        IF (err != NC_EBADID)
2179     error("bad ncid: status = %d", err);
2180        err = nc_put_var1_text(ncidBAD_VARIDindex, &value);
2181        IF (err != NC_ENOTVAR)
2182     error("bad var id: status = %d", err);
2183        for (j = 0; j < var_rank[i]; j++) {
2184     if (var_dimid[i][j] > 0) { /* skip record dim */
2185 index[j] = var_shape[i][j];
2186 err = nc_put_var1_text(ncidiindex, &value);
2187 IF (canConvert && err != NC_EINVALCOORDS)
2188     error("bad index: status = %d", err);
2189 index[j] = 0;
2190     }
2191        }
2192        for (j = 0; j < var_nels[i]; j++) {
2193            err = toMixedBase(jvar_rank[i], var_shape[i], index);
2194            IF (err)
2195 error("error in toMixedBase 1");
2196            value = hash_textvar_type[i], var_rank[i], indexNCT_TEXT);
2197     if (var_rank[i] == 0 && i%2 == 0)
2198 err = nc_put_var1_text(ncidiNULL, &value);
2199     else
2200 err = nc_put_var1_text(ncidiindex, &value);
2201     if (canConvert) {
2202 if (inRange3(valuevar_type[i],NCT_TEXT)) {
2203     IF (err)
2204 error("%s", nc_strerror(err));
2205 } else {
2206     IF (err != NC_ERANGE) {
2207 error("Range error: status = %d", err);
2208 error("\n\t\tfor type %s value %.17e %ld",
2209 s_nc_type(var_type[i]),
2210 (double)value, (long)value);
2211     }
2212 }
2213     } else {
2214 IF (err != NC_ECHAR)
2215     error("wrong type: status = %d", err);
2216            }
2217        }
2218    }
2219
2220    err = nc_close(ncid);
2221    IF (err)
2222 error("nc_close: %s", nc_strerror(err));
2223
2224    check_vars_text(scratch);
2225
2226    err = remove(scratch);
2227    IF (err)
2228        error("remove of %s failed", scratch);
2229}
2230
2231void
2232test_nc_put_var1_uchar(void)
2233{
2234    int ncid;
2235    int i;
2236    int j;
2237    int err;
2238    size_t index[MAX_RANK];
2239    int canConvert; /* Both text or both numeric */
2240    uchar value = 5; /* any value would do - only for error cases */
2241
2242    err = file_create(scratchNC_CLOBBER, &ncid);
2243    IF (err) {
2244        error("nc_create: %s", nc_strerror(err));
2245        return;
2246    }
2247    def_dims(ncid);
2248    def_vars(ncid);
2249    err = nc_enddef(ncid);
2250    IF (err)
2251        error("nc_enddef: %s", nc_strerror(err));
2252
2253#ifdef USE_PNETCDF
2254    {
2255    int format;
2256    nc_inq_format_extended(ncid, &formatNULL);
2257    if (format == NC_FORMATX_PNETCDF) {
2258        for (i = 0; i < numVarsi++) {
2259            err = nc_var_par_access(ncidiNC_COLLECTIVE);
2260     IF (err)
2261         error("nc_var_par_access: %s", nc_strerror(err));
2262        }
2263    }
2264    }
2265#endif
2266
2267    for (i = 0; i < numVarsi++) {
2268 canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
2269        for (j = 0; j < var_rank[i]; j++)
2270            index[j] = 0;
2271        err = nc_put_var1_uchar(BAD_IDiindex, &value);
2272        IF (err != NC_EBADID)
2273     error("bad ncid: status = %d", err);
2274        err = nc_put_var1_uchar(ncidBAD_VARIDindex, &value);
2275        IF (err != NC_ENOTVAR)
2276     error("bad var id: status = %d", err);
2277        for (j = 0; j < var_rank[i]; j++) {
2278     if (var_dimid[i][j] > 0) { /* skip record dim */
2279 index[j] = var_shape[i][j];
2280 err = nc_put_var1_uchar(ncidiindex, &value);
2281 IF (canConvert && err != NC_EINVALCOORDS)
2282     error("bad index: status = %d", err);
2283 index[j] = 0;
2284     }
2285        }
2286        for (j = 0; j < var_nels[i]; j++) {
2287            err = toMixedBase(jvar_rank[i], var_shape[i], index);
2288            IF (err)
2289 error("error in toMixedBase 1");
2290            value = hash_ucharvar_type[i], var_rank[i], indexNCT_UCHAR);
2291     if (var_rank[i] == 0 && i%2 == 0)
2292 err = nc_put_var1_uchar(ncidiNULL, &value);
2293     else
2294 err = nc_put_var1_uchar(ncidiindex, &value);
2295     if (canConvert) {
2296 if (inRange3(valuevar_type[i],NCT_UCHAR)) {
2297     IF (err)
2298 error("%s", nc_strerror(err));
2299 } else {
2300     IF (err != NC_ERANGE) {
2301 error("Range error: status = %d", err);
2302 error("\n\t\tfor type %s value %.17e %ld",
2303 s_nc_type(var_type[i]),
2304 (double)value, (long)value);
2305     }
2306 }
2307     } else {
2308 IF (err != NC_ECHAR)
2309     error("wrong type: status = %d", err);
2310            }
2311        }
2312    }
2313
2314    err = nc_close(ncid);
2315    IF (err)
2316 error("nc_close: %s", nc_strerror(err));
2317
2318    check_vars_uchar(scratch);
2319
2320    err = remove(scratch);
2321    IF (err)
2322        error("remove of %s failed", scratch);
2323}
2324
2325void
2326test_nc_put_var1_schar(void)
2327{
2328    int ncid;
2329    int i;
2330    int j;
2331    int err;
2332    size_t index[MAX_RANK];
2333    int canConvert; /* Both text or both numeric */
2334    schar value = 5; /* any value would do - only for error cases */
2335
2336    err = file_create(scratchNC_CLOBBER, &ncid);
2337    IF (err) {
2338        error("nc_create: %s", nc_strerror(err));
2339        return;
2340    }
2341    def_dims(ncid);
2342    def_vars(ncid);
2343    err = nc_enddef(ncid);
2344    IF (err)
2345        error("nc_enddef: %s", nc_strerror(err));
2346
2347#ifdef USE_PNETCDF
2348    {
2349    int format;
2350    nc_inq_format_extended(ncid, &formatNULL);
2351    if (format == NC_FORMATX_PNETCDF) {
2352        for (i = 0; i < numVarsi++) {
2353            err = nc_var_par_access(ncidiNC_COLLECTIVE);
2354     IF (err)
2355         error("nc_var_par_access: %s", nc_strerror(err));
2356        }
2357    }
2358    }
2359#endif
2360
2361    for (i = 0; i < numVarsi++) {
2362 canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
2363        for (j = 0; j < var_rank[i]; j++)
2364            index[j] = 0;
2365        err = nc_put_var1_schar(BAD_IDiindex, &value);
2366        IF (err != NC_EBADID)
2367     error("bad ncid: status = %d", err);
2368        err = nc_put_var1_schar(ncidBAD_VARIDindex, &value);
2369        IF (err != NC_ENOTVAR)
2370     error("bad var id: status = %d", err);
2371        for (j = 0; j < var_rank[i]; j++) {
2372     if (var_dimid[i][j] > 0) { /* skip record dim */
2373 index[j] = var_shape[i][j];
2374 err = nc_put_var1_schar(ncidiindex, &value);
2375 IF (canConvert && err != NC_EINVALCOORDS)
2376     error("bad index: status = %d", err);
2377 index[j] = 0;
2378     }
2379        }
2380        for (j = 0; j < var_nels[i]; j++) {
2381            err = toMixedBase(jvar_rank[i], var_shape[i], index);
2382            IF (err)
2383 error("error in toMixedBase 1");
2384            value = hash_scharvar_type[i], var_rank[i], indexNCT_SCHAR);
2385     if (var_rank[i] == 0 && i%2 == 0)
2386 err = nc_put_var1_schar(ncidiNULL, &value);
2387     else
2388 err = nc_put_var1_schar(ncidiindex, &value);
2389     if (canConvert) {
2390 if (inRange3(valuevar_type[i],NCT_SCHAR)) {
2391     IF (err)
2392 error("%s", nc_strerror(err));
2393 } else {
2394     IF (err != NC_ERANGE) {
2395 error("Range error: status = %d", err);
2396 error("\n\t\tfor type %s value %.17e %ld",
2397 s_nc_type(var_type[i]),
2398 (double)value, (long)value);
2399     }
2400 }
2401     } else {
2402 IF (err != NC_ECHAR)
2403     error("wrong type: status = %d", err);
2404            }
2405        }
2406    }
2407
2408    err = nc_close(ncid);
2409    IF (err)
2410 error("nc_close: %s", nc_strerror(err));
2411
2412    check_vars_schar(scratch);
2413
2414    err = remove(scratch);
2415    IF (err)
2416        error("remove of %s failed", scratch);
2417}
2418
2419void
2420test_nc_put_var1_short(void)
2421{
2422    int ncid;
2423    int i;
2424    int j;
2425    int err;
2426    size_t index[MAX_RANK];
2427    int canConvert; /* Both text or both numeric */
2428    short value = 5; /* any value would do - only for error cases */
2429
2430    err = file_create(scratchNC_CLOBBER, &ncid);
2431    IF (err) {
2432        error("nc_create: %s", nc_strerror(err));
2433        return;
2434    }
2435    def_dims(ncid);
2436    def_vars(ncid);
2437    err = nc_enddef(ncid);
2438    IF (err)
2439        error("nc_enddef: %s", nc_strerror(err));
2440
2441#ifdef USE_PNETCDF
2442    {
2443    int format;
2444    nc_inq_format_extended(ncid, &formatNULL);
2445    if (format == NC_FORMATX_PNETCDF) {
2446        for (i = 0; i < numVarsi++) {
2447            err = nc_var_par_access(ncidiNC_COLLECTIVE);
2448     IF (err)
2449         error("nc_var_par_access: %s", nc_strerror(err));
2450        }
2451    }
2452    }
2453#endif
2454
2455    for (i = 0; i < numVarsi++) {
2456 canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
2457        for (j = 0; j < var_rank[i]; j++)
2458            index[j] = 0;
2459        err = nc_put_var1_short(BAD_IDiindex, &value);
2460        IF (err != NC_EBADID)
2461     error("bad ncid: status = %d", err);
2462        err = nc_put_var1_short(ncidBAD_VARIDindex, &value);
2463        IF (err != NC_ENOTVAR)
2464     error("bad var id: status = %d", err);
2465        for (j = 0; j < var_rank[i]; j++) {
2466     if (var_dimid[i][j] > 0) { /* skip record dim */
2467 index[j] = var_shape[i][j];
2468 err = nc_put_var1_short(ncidiindex, &value);
2469 IF (canConvert && err != NC_EINVALCOORDS)
2470     error("bad index: status = %d", err);
2471 index[j] = 0;
2472     }
2473        }
2474        for (j = 0; j < var_nels[i]; j++) {
2475            err = toMixedBase(jvar_rank[i], var_shape[i], index);
2476            IF (err)
2477 error("error in toMixedBase 1");
2478            value = hash_shortvar_type[i], var_rank[i], indexNCT_SHORT);
2479     if (var_rank[i] == 0 && i%2 == 0)
2480 err = nc_put_var1_short(ncidiNULL, &value);
2481     else
2482 err = nc_put_var1_short(ncidiindex, &value);
2483     if (canConvert) {
2484 if (inRange3(valuevar_type[i],NCT_SHORT)) {
2485     IF (err)
2486 error("%s", nc_strerror(err));
2487 } else {
2488     IF (err != NC_ERANGE) {
2489 error("Range error: status = %d", err);
2490 error("\n\t\tfor type %s value %.17e %ld",
2491 s_nc_type(var_type[i]),
2492 (double)value, (long)value);
2493     }
2494 }
2495     } else {
2496 IF (err != NC_ECHAR)
2497     error("wrong type: status = %d", err);
2498            }
2499        }
2500    }
2501
2502    err = nc_close(ncid);
2503    IF (err)
2504 error("nc_close: %s", nc_strerror(err));
2505
2506    check_vars_short(scratch);
2507
2508    err = remove(scratch);
2509    IF (err)
2510        error("remove of %s failed", scratch);
2511}
2512
2513void
2514test_nc_put_var1_int(void)
2515{
2516    int ncid;
2517    int i;
2518    int j;
2519    int err;
2520    size_t index[MAX_RANK];
2521    int canConvert; /* Both text or both numeric */
2522    int value = 5; /* any value would do - only for error cases */
2523
2524    err = file_create(scratchNC_CLOBBER, &ncid);
2525    IF (err) {
2526        error("nc_create: %s", nc_strerror(err));
2527        return;
2528    }
2529    def_dims(ncid);
2530    def_vars(ncid);
2531    err = nc_enddef(ncid);
2532    IF (err)
2533        error("nc_enddef: %s", nc_strerror(err));
2534
2535#ifdef USE_PNETCDF
2536    {
2537    int format;
2538    nc_inq_format_extended(ncid, &formatNULL);
2539    if (format == NC_FORMATX_PNETCDF) {
2540        for (i = 0; i < numVarsi++) {
2541            err = nc_var_par_access(ncidiNC_COLLECTIVE);
2542     IF (err)
2543         error("nc_var_par_access: %s", nc_strerror(err));
2544        }
2545    }
2546    }
2547#endif
2548
2549    for (i = 0; i < numVarsi++) {
2550 canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
2551        for (j = 0; j < var_rank[i]; j++)
2552            index[j] = 0;
2553        err = nc_put_var1_int(BAD_IDiindex, &value);
2554        IF (err != NC_EBADID)
2555     error("bad ncid: status = %d", err);
2556        err = nc_put_var1_int(ncidBAD_VARIDindex, &value);
2557        IF (err != NC_ENOTVAR)
2558     error("bad var id: status = %d", err);
2559        for (j = 0; j < var_rank[i]; j++) {
2560     if (var_dimid[i][j] > 0) { /* skip record dim */
2561 index[j] = var_shape[i][j];
2562 err = nc_put_var1_int(ncidiindex, &value);
2563 IF (canConvert && err != NC_EINVALCOORDS)
2564     error("bad index: status = %d", err);
2565 index[j] = 0;
2566     }
2567        }
2568        for (j = 0; j < var_nels[i]; j++) {
2569            err = toMixedBase(jvar_rank[i], var_shape[i], index);
2570            IF (err)
2571 error("error in toMixedBase 1");
2572            value = hash_intvar_type[i], var_rank[i], indexNCT_INT);
2573     if (var_rank[i] == 0 && i%2 == 0)
2574 err = nc_put_var1_int(ncidiNULL, &value);
2575     else
2576 err = nc_put_var1_int(ncidiindex, &value);
2577     if (canConvert) {
2578 if (inRange3(valuevar_type[i],NCT_INT)) {
2579     IF (err)
2580 error("%s", nc_strerror(err));
2581 } else {
2582     IF (err != NC_ERANGE) {
2583 error("Range error: status = %d", err);
2584 error("\n\t\tfor type %s value %.17e %ld",
2585 s_nc_type(var_type[i]),
2586 (double)value, (long)value);
2587     }
2588 }
2589     } else {
2590 IF (err != NC_ECHAR)
2591     error("wrong type: status = %d", err);
2592            }
2593        }
2594    }
2595
2596    err = nc_close(ncid);
2597    IF (err)
2598 error("nc_close: %s", nc_strerror(err));
2599
2600    check_vars_int(scratch);
2601
2602    err = remove(scratch);
2603    IF (err)
2604        error("remove of %s failed", scratch);
2605}
2606
2607void
2608test_nc_put_var1_long(void)
2609{
2610    int ncid;
2611    int i;
2612    int j;
2613    int err;
2614    size_t index[MAX_RANK];
2615    int canConvert; /* Both text or both numeric */
2616    long value = 5; /* any value would do - only for error cases */
2617
2618    err = file_create(scratchNC_CLOBBER, &ncid);
2619    IF (err) {
2620        error("nc_create: %s", nc_strerror(err));
2621        return;
2622    }
2623    def_dims(ncid);
2624    def_vars(ncid);
2625    err = nc_enddef(ncid);
2626    IF (err)
2627        error("nc_enddef: %s", nc_strerror(err));
2628
2629#ifdef USE_PNETCDF
2630    {
2631    int format;
2632    nc_inq_format_extended(ncid, &formatNULL);
2633    if (format == NC_FORMATX_PNETCDF) {
2634        for (i = 0; i < numVarsi++) {
2635            err = nc_var_par_access(ncidiNC_COLLECTIVE);
2636     IF (err)
2637         error("nc_var_par_access: %s", nc_strerror(err));
2638        }
2639    }
2640    }
2641#endif
2642
2643    for (i = 0; i < numVarsi++) {
2644 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
2645        for (j = 0; j < var_rank[i]; j++)
2646            index[j] = 0;
2647        err = nc_put_var1_long(BAD_IDiindex, &value);
2648        IF (err != NC_EBADID)
2649     error("bad ncid: status = %d", err);
2650        err = nc_put_var1_long(ncidBAD_VARIDindex, &value);
2651        IF (err != NC_ENOTVAR)
2652     error("bad var id: status = %d", err);
2653        for (j = 0; j < var_rank[i]; j++) {
2654     if (var_dimid[i][j] > 0) { /* skip record dim */
2655 index[j] = var_shape[i][j];
2656 err = nc_put_var1_long(ncidiindex, &value);
2657 IF (canConvert && err != NC_EINVALCOORDS)
2658     error("bad index: status = %d", err);
2659 index[j] = 0;
2660     }
2661        }
2662        for (j = 0; j < var_nels[i]; j++) {
2663            err = toMixedBase(jvar_rank[i], var_shape[i], index);
2664            IF (err)
2665 error("error in toMixedBase 1");
2666            value = hash_longvar_type[i], var_rank[i], indexNCT_LONG);
2667     if (var_rank[i] == 0 && i%2 == 0)
2668 err = nc_put_var1_long(ncidiNULL, &value);
2669     else
2670 err = nc_put_var1_long(ncidiindex, &value);
2671     if (canConvert) {
2672 if (inRange3(valuevar_type[i],NCT_LONG)) {
2673     IF (err)
2674 error("%s", nc_strerror(err));
2675 } else {
2676     IF (err != NC_ERANGE) {
2677 error("Range error: status = %d", err);
2678 error("\n\t\tfor type %s value %.17e %ld",
2679 s_nc_type(var_type[i]),
2680 (double)value, (long)value);
2681     }
2682 }
2683     } else {
2684 IF (err != NC_ECHAR)
2685     error("wrong type: status = %d", err);
2686            }
2687        }
2688    }
2689
2690    err = nc_close(ncid);
2691    IF (err)
2692 error("nc_close: %s", nc_strerror(err));
2693
2694    check_vars_long(scratch);
2695
2696    err = remove(scratch);
2697    IF (err)
2698        error("remove of %s failed", scratch);
2699}
2700
2701void
2702test_nc_put_var1_float(void)
2703{
2704    int ncid;
2705    int i;
2706    int j;
2707    int err;
2708    size_t index[MAX_RANK];
2709    int canConvert; /* Both text or both numeric */
2710    float value = 5; /* any value would do - only for error cases */
2711
2712    err = file_create(scratchNC_CLOBBER, &ncid);
2713    IF (err) {
2714        error("nc_create: %s", nc_strerror(err));
2715        return;
2716    }
2717    def_dims(ncid);
2718    def_vars(ncid);
2719    err = nc_enddef(ncid);
2720    IF (err)
2721        error("nc_enddef: %s", nc_strerror(err));
2722
2723#ifdef USE_PNETCDF
2724    {
2725    int format;
2726    nc_inq_format_extended(ncid, &formatNULL);
2727    if (format == NC_FORMATX_PNETCDF) {
2728        for (i = 0; i < numVarsi++) {
2729            err = nc_var_par_access(ncidiNC_COLLECTIVE);
2730     IF (err)
2731         error("nc_var_par_access: %s", nc_strerror(err));
2732        }
2733    }
2734    }
2735#endif
2736
2737    for (i = 0; i < numVarsi++) {
2738 canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
2739        for (j = 0; j < var_rank[i]; j++)
2740            index[j] = 0;
2741        err = nc_put_var1_float(BAD_IDiindex, &value);
2742        IF (err != NC_EBADID)
2743     error("bad ncid: status = %d", err);
2744        err = nc_put_var1_float(ncidBAD_VARIDindex, &value);
2745        IF (err != NC_ENOTVAR)
2746     error("bad var id: status = %d", err);
2747        for (j = 0; j < var_rank[i]; j++) {
2748     if (var_dimid[i][j] > 0) { /* skip record dim */
2749 index[j] = var_shape[i][j];
2750 err = nc_put_var1_float(ncidiindex, &value);
2751 IF (canConvert && err != NC_EINVALCOORDS)
2752     error("bad index: status = %d", err);
2753 index[j] = 0;
2754     }
2755        }
2756        for (j = 0; j < var_nels[i]; j++) {
2757            err = toMixedBase(jvar_rank[i], var_shape[i], index);
2758            IF (err)
2759 error("error in toMixedBase 1");
2760            value = hash_floatvar_type[i], var_rank[i], indexNCT_FLOAT);
2761     if (var_rank[i] == 0 && i%2 == 0)
2762 err = nc_put_var1_float(ncidiNULL, &value);
2763     else
2764 err = nc_put_var1_float(ncidiindex, &value);
2765     if (canConvert) {
2766 if (inRange3(valuevar_type[i],NCT_FLOAT)) {
2767     IF (err)
2768 error("%s", nc_strerror(err));
2769 } else {
2770     IF (err != NC_ERANGE) {
2771 error("Range error: status = %d", err);
2772 error("\n\t\tfor type %s value %.17e %ld",
2773 s_nc_type(var_type[i]),
2774 (double)value, (long)value);
2775     }
2776 }
2777     } else {
2778 IF (err != NC_ECHAR)
2779     error("wrong type: status = %d", err);
2780            }
2781        }
2782    }
2783
2784    err = nc_close(ncid);
2785    IF (err)
2786 error("nc_close: %s", nc_strerror(err));
2787
2788    check_vars_float(scratch);
2789
2790    err = remove(scratch);
2791    IF (err)
2792        error("remove of %s failed", scratch);
2793}
2794
2795void
2796test_nc_put_var1_double(void)
2797{
2798    int ncid;
2799    int i;
2800    int j;
2801    int err;
2802    size_t index[MAX_RANK];
2803    int canConvert; /* Both text or both numeric */
2804    double value = 5; /* any value would do - only for error cases */
2805
2806    err = file_create(scratchNC_CLOBBER, &ncid);
2807    IF (err) {
2808        error("nc_create: %s", nc_strerror(err));
2809        return;
2810    }
2811    def_dims(ncid);
2812    def_vars(ncid);
2813    err = nc_enddef(ncid);
2814    IF (err)
2815        error("nc_enddef: %s", nc_strerror(err));
2816
2817#ifdef USE_PNETCDF
2818    {
2819    int format;
2820    nc_inq_format_extended(ncid, &formatNULL);
2821    if (format == NC_FORMATX_PNETCDF) {
2822        for (i = 0; i < numVarsi++) {
2823            err = nc_var_par_access(ncidiNC_COLLECTIVE);
2824     IF (err)
2825         error("nc_var_par_access: %s", nc_strerror(err));
2826        }
2827    }
2828    }
2829#endif
2830
2831    for (i = 0; i < numVarsi++) {
2832 canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
2833        for (j = 0; j < var_rank[i]; j++)
2834            index[j] = 0;
2835        err = nc_put_var1_double(BAD_IDiindex, &value);
2836        IF (err != NC_EBADID)
2837     error("bad ncid: status = %d", err);
2838        err = nc_put_var1_double(ncidBAD_VARIDindex, &value);
2839        IF (err != NC_ENOTVAR)
2840     error("bad var id: status = %d", err);
2841        for (j = 0; j < var_rank[i]; j++) {
2842     if (var_dimid[i][j] > 0) { /* skip record dim */
2843 index[j] = var_shape[i][j];
2844 err = nc_put_var1_double(ncidiindex, &value);
2845 IF (canConvert && err != NC_EINVALCOORDS)
2846     error("bad index: status = %d", err);
2847 index[j] = 0;
2848     }
2849        }
2850        for (j = 0; j < var_nels[i]; j++) {
2851            err = toMixedBase(jvar_rank[i], var_shape[i], index);
2852            IF (err)
2853 error("error in toMixedBase 1");
2854            value = hash_doublevar_type[i], var_rank[i], indexNCT_DOUBLE);
2855     if (var_rank[i] == 0 && i%2 == 0)
2856 err = nc_put_var1_double(ncidiNULL, &value);
2857     else
2858 err = nc_put_var1_double(ncidiindex, &value);
2859     if (canConvert) {
2860 if (inRange3(valuevar_type[i],NCT_DOUBLE)) {
2861     IF (err)
2862 error("%s", nc_strerror(err));
2863 } else {
2864     IF (err != NC_ERANGE) {
2865 error("Range error: status = %d", err);
2866 error("\n\t\tfor type %s value %.17e %ld",
2867 s_nc_type(var_type[i]),
2868 (double)value, (long)value);
2869     }
2870 }
2871     } else {
2872 IF (err != NC_ECHAR)
2873     error("wrong type: status = %d", err);
2874            }
2875        }
2876    }
2877
2878    err = nc_close(ncid);
2879    IF (err)
2880 error("nc_close: %s", nc_strerror(err));
2881
2882    check_vars_double(scratch);
2883
2884    err = remove(scratch);
2885    IF (err)
2886        error("remove of %s failed", scratch);
2887}
2888
2889void
2890test_nc_put_var1_ushort(void)
2891{
2892    int ncid;
2893    int i;
2894    int j;
2895    int err;
2896    size_t index[MAX_RANK];
2897    int canConvert; /* Both text or both numeric */
2898    ushort value = 5; /* any value would do - only for error cases */
2899
2900    err = file_create(scratchNC_CLOBBER, &ncid);
2901    IF (err) {
2902        error("nc_create: %s", nc_strerror(err));
2903        return;
2904    }
2905    def_dims(ncid);
2906    def_vars(ncid);
2907    err = nc_enddef(ncid);
2908    IF (err)
2909        error("nc_enddef: %s", nc_strerror(err));
2910
2911#ifdef USE_PNETCDF
2912    {
2913    int format;
2914    nc_inq_format_extended(ncid, &formatNULL);
2915    if (format == NC_FORMATX_PNETCDF) {
2916        for (i = 0; i < numVarsi++) {
2917            err = nc_var_par_access(ncidiNC_COLLECTIVE);
2918     IF (err)
2919         error("nc_var_par_access: %s", nc_strerror(err));
2920        }
2921    }
2922    }
2923#endif
2924
2925    for (i = 0; i < numVarsi++) {
2926 canConvert = (var_type[i] == NC_CHAR) == (NCT_USHORT == NCT_TEXT);
2927        for (j = 0; j < var_rank[i]; j++)
2928            index[j] = 0;
2929        err = nc_put_var1_ushort(BAD_IDiindex, &value);
2930        IF (err != NC_EBADID)
2931     error("bad ncid: status = %d", err);
2932        err = nc_put_var1_ushort(ncidBAD_VARIDindex, &value);
2933        IF (err != NC_ENOTVAR)
2934     error("bad var id: status = %d", err);
2935        for (j = 0; j < var_rank[i]; j++) {
2936     if (var_dimid[i][j] > 0) { /* skip record dim */
2937 index[j] = var_shape[i][j];
2938 err = nc_put_var1_ushort(ncidiindex, &value);
2939 IF (canConvert && err != NC_EINVALCOORDS)
2940     error("bad index: status = %d", err);
2941 index[j] = 0;
2942     }
2943        }
2944        for (j = 0; j < var_nels[i]; j++) {
2945            err = toMixedBase(jvar_rank[i], var_shape[i], index);
2946            IF (err)
2947 error("error in toMixedBase 1");
2948            value = hash_ushortvar_type[i], var_rank[i], indexNCT_USHORT);
2949     if (var_rank[i] == 0 && i%2 == 0)
2950 err = nc_put_var1_ushort(ncidiNULL, &value);
2951     else
2952 err = nc_put_var1_ushort(ncidiindex, &value);
2953     if (canConvert) {
2954 if (inRange3(valuevar_type[i],NCT_USHORT)) {
2955     IF (err)
2956 error("%s", nc_strerror(err));
2957 } else {
2958     IF (err != NC_ERANGE) {
2959 error("Range error: status = %d", err);
2960 error("\n\t\tfor type %s value %.17e %ld",
2961 s_nc_type(var_type[i]),
2962 (double)value, (long)value);
2963     }
2964 }
2965     } else {
2966 IF (err != NC_ECHAR)
2967     error("wrong type: status = %d", err);
2968            }
2969        }
2970    }
2971
2972    err = nc_close(ncid);
2973    IF (err)
2974 error("nc_close: %s", nc_strerror(err));
2975
2976    check_vars_ushort(scratch);
2977
2978    err = remove(scratch);
2979    IF (err)
2980        error("remove of %s failed", scratch);
2981}
2982
2983void
2984test_nc_put_var1_uint(void)
2985{
2986    int ncid;
2987    int i;
2988    int j;
2989    int err;
2990    size_t index[MAX_RANK];
2991    int canConvert; /* Both text or both numeric */
2992    uint value = 5; /* any value would do - only for error cases */
2993
2994    err = file_create(scratchNC_CLOBBER, &ncid);
2995    IF (err) {
2996        error("nc_create: %s", nc_strerror(err));
2997        return;
2998    }
2999    def_dims(ncid);
3000    def_vars(ncid);
3001    err = nc_enddef(ncid);
3002    IF (err)
3003        error("nc_enddef: %s", nc_strerror(err));
3004
3005#ifdef USE_PNETCDF
3006    {
3007    int format;
3008    nc_inq_format_extended(ncid, &formatNULL);
3009    if (format == NC_FORMATX_PNETCDF) {
3010        for (i = 0; i < numVarsi++) {
3011            err = nc_var_par_access(ncidiNC_COLLECTIVE);
3012     IF (err)
3013         error("nc_var_par_access: %s", nc_strerror(err));
3014        }
3015    }
3016    }
3017#endif
3018
3019    for (i = 0; i < numVarsi++) {
3020 canConvert = (var_type[i] == NC_CHAR) == (NCT_UINT == NCT_TEXT);
3021        for (j = 0; j < var_rank[i]; j++)
3022            index[j] = 0;
3023        err = nc_put_var1_uint(BAD_IDiindex, &value);
3024        IF (err != NC_EBADID)
3025     error("bad ncid: status = %d", err);
3026        err = nc_put_var1_uint(ncidBAD_VARIDindex, &value);
3027        IF (err != NC_ENOTVAR)
3028     error("bad var id: status = %d", err);
3029        for (j = 0; j < var_rank[i]; j++) {
3030     if (var_dimid[i][j] > 0) { /* skip record dim */
3031 index[j] = var_shape[i][j];
3032 err = nc_put_var1_uint(ncidiindex, &value);
3033 IF (canConvert && err != NC_EINVALCOORDS)
3034     error("bad index: status = %d", err);
3035 index[j] = 0;
3036     }
3037        }
3038        for (j = 0; j < var_nels[i]; j++) {
3039            err = toMixedBase(jvar_rank[i], var_shape[i], index);
3040            IF (err)
3041 error("error in toMixedBase 1");
3042            value = hash_uintvar_type[i], var_rank[i], indexNCT_UINT);
3043     if (var_rank[i] == 0 && i%2 == 0)
3044 err = nc_put_var1_uint(ncidiNULL, &value);
3045     else
3046 err = nc_put_var1_uint(ncidiindex, &value);
3047     if (canConvert) {
3048 if (inRange3(valuevar_type[i],NCT_UINT)) {
3049     IF (err)
3050 error("%s", nc_strerror(err));
3051 } else {
3052     IF (err != NC_ERANGE) {
3053 error("Range error: status = %d", err);
3054 error("\n\t\tfor type %s value %.17e %ld",
3055 s_nc_type(var_type[i]),
3056 (double)value, (long)value);
3057     }
3058 }
3059     } else {
3060 IF (err != NC_ECHAR)
3061     error("wrong type: status = %d", err);
3062            }
3063        }
3064    }
3065
3066    err = nc_close(ncid);
3067    IF (err)
3068 error("nc_close: %s", nc_strerror(err));
3069
3070    check_vars_uint(scratch);
3071
3072    err = remove(scratch);
3073    IF (err)
3074        error("remove of %s failed", scratch);
3075}
3076
3077void
3078test_nc_put_var1_longlong(void)
3079{
3080    int ncid;
3081    int i;
3082    int j;
3083    int err;
3084    size_t index[MAX_RANK];
3085    int canConvert; /* Both text or both numeric */
3086    longlong value = 5; /* any value would do - only for error cases */
3087
3088    err = file_create(scratchNC_CLOBBER, &ncid);
3089    IF (err) {
3090        error("nc_create: %s", nc_strerror(err));
3091        return;
3092    }
3093    def_dims(ncid);
3094    def_vars(ncid);
3095    err = nc_enddef(ncid);
3096    IF (err)
3097        error("nc_enddef: %s", nc_strerror(err));
3098
3099#ifdef USE_PNETCDF
3100    {
3101    int format;
3102    nc_inq_format_extended(ncid, &formatNULL);
3103    if (format == NC_FORMATX_PNETCDF) {
3104        for (i = 0; i < numVarsi++) {
3105            err = nc_var_par_access(ncidiNC_COLLECTIVE);
3106     IF (err)
3107         error("nc_var_par_access: %s", nc_strerror(err));
3108        }
3109    }
3110    }
3111#endif
3112
3113    for (i = 0; i < numVarsi++) {
3114 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONGLONG == NCT_TEXT);
3115        for (j = 0; j < var_rank[i]; j++)
3116            index[j] = 0;
3117        err = nc_put_var1_longlong(BAD_IDiindex, &value);
3118        IF (err != NC_EBADID)
3119     error("bad ncid: status = %d", err);
3120        err = nc_put_var1_longlong(ncidBAD_VARIDindex, &value);
3121        IF (err != NC_ENOTVAR)
3122     error("bad var id: status = %d", err);
3123        for (j = 0; j < var_rank[i]; j++) {
3124     if (var_dimid[i][j] > 0) { /* skip record dim */
3125 index[j] = var_shape[i][j];
3126 err = nc_put_var1_longlong(ncidiindex, &value);
3127 IF (canConvert && err != NC_EINVALCOORDS)
3128     error("bad index: status = %d", err);
3129 index[j] = 0;
3130     }
3131        }
3132        for (j = 0; j < var_nels[i]; j++) {
3133            err = toMixedBase(jvar_rank[i], var_shape[i], index);
3134            IF (err)
3135 error("error in toMixedBase 1");
3136            value = hash_longlongvar_type[i], var_rank[i], indexNCT_LONGLONG);
3137     if (var_rank[i] == 0 && i%2 == 0)
3138 err = nc_put_var1_longlong(ncidiNULL, &value);
3139     else
3140 err = nc_put_var1_longlong(ncidiindex, &value);
3141     if (canConvert) {
3142 if (inRange3(valuevar_type[i],NCT_LONGLONG)) {
3143     IF (err)
3144 error("%s", nc_strerror(err));
3145 } else {
3146     IF (err != NC_ERANGE) {
3147 error("Range error: status = %d", err);
3148 error("\n\t\tfor type %s value %.17e %ld",
3149 s_nc_type(var_type[i]),
3150 (double)value, (long)value);
3151     }
3152 }
3153     } else {
3154 IF (err != NC_ECHAR)
3155     error("wrong type: status = %d", err);
3156            }
3157        }
3158    }
3159
3160    err = nc_close(ncid);
3161    IF (err)
3162 error("nc_close: %s", nc_strerror(err));
3163
3164    check_vars_longlong(scratch);
3165
3166    err = remove(scratch);
3167    IF (err)
3168        error("remove of %s failed", scratch);
3169}
3170
3171void
3172test_nc_put_var1_ulonglong(void)
3173{
3174    int ncid;
3175    int i;
3176    int j;
3177    int err;
3178    size_t index[MAX_RANK];
3179    int canConvert; /* Both text or both numeric */
3180    ulonglong value = 5; /* any value would do - only for error cases */
3181
3182    err = file_create(scratchNC_CLOBBER, &ncid);
3183    IF (err) {
3184        error("nc_create: %s", nc_strerror(err));
3185        return;
3186    }
3187    def_dims(ncid);
3188    def_vars(ncid);
3189    err = nc_enddef(ncid);
3190    IF (err)
3191        error("nc_enddef: %s", nc_strerror(err));
3192
3193#ifdef USE_PNETCDF
3194    {
3195    int format;
3196    nc_inq_format_extended(ncid, &formatNULL);
3197    if (format == NC_FORMATX_PNETCDF) {
3198        for (i = 0; i < numVarsi++) {
3199            err = nc_var_par_access(ncidiNC_COLLECTIVE);
3200     IF (err)
3201         error("nc_var_par_access: %s", nc_strerror(err));
3202        }
3203    }
3204    }
3205#endif
3206
3207    for (i = 0; i < numVarsi++) {
3208 canConvert = (var_type[i] == NC_CHAR) == (NCT_ULONGLONG == NCT_TEXT);
3209        for (j = 0; j < var_rank[i]; j++)
3210            index[j] = 0;
3211        err = nc_put_var1_ulonglong(BAD_IDiindex, &value);
3212        IF (err != NC_EBADID)
3213     error("bad ncid: status = %d", err);
3214        err = nc_put_var1_ulonglong(ncidBAD_VARIDindex, &value);
3215        IF (err != NC_ENOTVAR)
3216     error("bad var id: status = %d", err);
3217        for (j = 0; j < var_rank[i]; j++) {
3218     if (var_dimid[i][j] > 0) { /* skip record dim */
3219 index[j] = var_shape[i][j];
3220 err = nc_put_var1_ulonglong(ncidiindex, &value);
3221 IF (canConvert && err != NC_EINVALCOORDS)
3222     error("bad index: status = %d", err);
3223 index[j] = 0;
3224     }
3225        }
3226        for (j = 0; j < var_nels[i]; j++) {
3227            err = toMixedBase(jvar_rank[i], var_shape[i], index);
3228            IF (err)
3229 error("error in toMixedBase 1");
3230            value = hash_ulonglongvar_type[i], var_rank[i], indexNCT_ULONGLONG);
3231     if (var_rank[i] == 0 && i%2 == 0)
3232 err = nc_put_var1_ulonglong(ncidiNULL, &value);
3233     else
3234 err = nc_put_var1_ulonglong(ncidiindex, &value);
3235     if (canConvert) {
3236 if (inRange3(valuevar_type[i],NCT_ULONGLONG)) {
3237     IF (err)
3238 error("%s", nc_strerror(err));
3239 } else {
3240     IF (err != NC_ERANGE) {
3241 error("Range error: status = %d", err);
3242 error("\n\t\tfor type %s value %.17e %ld",
3243 s_nc_type(var_type[i]),
3244 (double)value, (long)value);
3245     }
3246 }
3247     } else {
3248 IF (err != NC_ECHAR)
3249     error("wrong type: status = %d", err);
3250            }
3251        }
3252    }
3253
3254    err = nc_close(ncid);
3255    IF (err)
3256 error("nc_close: %s", nc_strerror(err));
3257
3258    check_vars_ulonglong(scratch);
3259
3260    err = remove(scratch);
3261    IF (err)
3262        error("remove of %s failed", scratch);
3263}
3264
3265
3266
3267
3268void
3269test_nc_put_var_text(void)
3270{
3271    int ncid;
3272    int varid;
3273    int i;
3274    int j;
3275    int err;
3276    int nels;
3277    size_t index[MAX_RANK];
3278    int canConvert; /* Both text or both numeric */
3279    int allInExtRange; /* all values within external range? */
3280    text value[MAX_NELS];
3281
3282    err = file_create(scratchNC_CLOBBER, &ncid);
3283    IF (err) {
3284        error("nc_create: %s", nc_strerror(err));
3285        return;
3286    }
3287    def_dims(ncid);
3288    def_vars(ncid);
3289    err = nc_enddef(ncid);
3290    IF (err)
3291        error("nc_enddef: %s", nc_strerror(err));
3292
3293#ifdef USE_PNETCDF
3294    {
3295    int format;
3296    nc_inq_format_extended(ncid, &formatNULL);
3297    if (format == NC_FORMATX_PNETCDF) {
3298        for (i = 0; i < numVarsi++) {
3299            err = nc_var_par_access(ncidiNC_COLLECTIVE);
3300     IF (err)
3301         error("nc_var_par_access: %s", nc_strerror(err));
3302        }
3303    }
3304    }
3305#endif
3306
3307    for (i = 0; i < numVarsi++) {
3308 canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
3309        assert(var_rank[i] <= MAX_RANK);
3310        assert(var_nels[i] <= MAX_NELS);
3311        err = nc_put_var_text(BAD_IDivalue);
3312        IF (err != NC_EBADID)
3313     error("bad ncid: status = %d", err);
3314        err = nc_put_var_text(ncidBAD_VARIDvalue);
3315        IF (err != NC_ENOTVAR)
3316     error("bad var id: status = %d", err);
3317
3318 nels = 1;
3319 for (j = 0; j < var_rank[i]; j++) {
3320     nels *= var_shape[i][j];
3321 }
3322 for (allInExtRange = 1, j = 0; j < nelsj++) {
3323     err = toMixedBase(jvar_rank[i], var_shape[i], index);
3324     IF (err)
3325 error("error in toMixedBase 1");
3326     value[j]= hash_text(var_type[i], var_rank[i], indexNCT_TEXT);
3327     allInExtRange = allInExtRange
3328 && inRange3(value[j], var_type[i], NCT_TEXT);
3329 }
3330        err = nc_put_var_text(ncidivalue);
3331 if (canConvert) {
3332     if (allInExtRange) {
3333 IF (err)
3334     error("%s", nc_strerror(err));
3335     } else {
3336 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
3337     error("range error: status = %d", err);
3338     }
3339 } else {       /* should flag wrong type even if nothing to write */
3340     IF (nels > 0 && err != NC_ECHAR)
3341 error("wrong type: status = %d", err);
3342 }
3343    }
3344
3345        /* Preceding has written nothing for record variables, now try */
3346        /* again with more than 0 records */
3347
3348 /* Write record number NRECS to force writing of preceding records */
3349 /* Assumes variable cr is char vector with UNLIMITED dimension */
3350    err = nc_inq_varid(ncid, "cr", &varid);
3351    IF (err)
3352        error("nc_inq_varid: %s", nc_strerror(err));
3353    index[0] = NRECS-1;
3354    err = nc_put_var1_text(ncidvaridindex, "x");
3355    IF (err)
3356        error("nc_put_var1_text: %s", nc_strerror(err));
3357
3358    for (i = 0; i < numVarsi++) {
3359        if (var_dimid[i][0] == RECDIM) {  /* only test record variables here */
3360     canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
3361     assert(var_rank[i] <= MAX_RANK);
3362     assert(var_nels[i] <= MAX_NELS);
3363     err = nc_put_var_text(BAD_IDivalue);
3364     IF (err != NC_EBADID)
3365         error("bad ncid: status = %d", err);
3366     nels = 1;
3367     for (j = 0; j < var_rank[i]; j++) {
3368 nels *= var_shape[i][j];
3369     }
3370     for (allInExtRange = 1, j = 0; j < nelsj++) {
3371 err = toMixedBase(jvar_rank[i], var_shape[i], index);
3372 IF (err)
3373     error("error in toMixedBase 1");
3374 value[j]= hash_text(var_type[i], var_rank[i], indexNCT_TEXT);
3375 allInExtRange = allInExtRange
3376     && inRange3(value[j], var_type[i], NCT_TEXT);
3377     }
3378     err = nc_put_var_text(ncidivalue);
3379     if (canConvert) {
3380 if (allInExtRange) {
3381     IF (err)
3382 error("%s", nc_strerror(err));
3383 } else {
3384     IF (err != NC_ERANGE)
3385 error("range error: status = %d", err);
3386 }
3387     } else {
3388 IF (nels > 0 && err != NC_ECHAR)
3389     error("wrong type: status = %d", err);
3390     }
3391        }
3392    }
3393
3394    err = nc_close(ncid);
3395    IF (err)
3396 error("nc_close: %s", nc_strerror(err));
3397
3398    check_vars_text(scratch);
3399
3400    err = remove(scratch);
3401    IF (err)
3402        error("remove of %s failed", scratch);
3403}
3404
3405void
3406test_nc_put_var_uchar(void)
3407{
3408    int ncid;
3409    int varid;
3410    int i;
3411    int j;
3412    int err;
3413    int nels;
3414    size_t index[MAX_RANK];
3415    int canConvert; /* Both text or both numeric */
3416    int allInExtRange; /* all values within external range? */
3417    uchar value[MAX_NELS];
3418
3419    err = file_create(scratchNC_CLOBBER, &ncid);
3420    IF (err) {
3421        error("nc_create: %s", nc_strerror(err));
3422        return;
3423    }
3424    def_dims(ncid);
3425    def_vars(ncid);
3426    err = nc_enddef(ncid);
3427    IF (err)
3428        error("nc_enddef: %s", nc_strerror(err));
3429
3430#ifdef USE_PNETCDF
3431    {
3432    int format;
3433    nc_inq_format_extended(ncid, &formatNULL);
3434    if (format == NC_FORMATX_PNETCDF) {
3435        for (i = 0; i < numVarsi++) {
3436            err = nc_var_par_access(ncidiNC_COLLECTIVE);
3437     IF (err)
3438         error("nc_var_par_access: %s", nc_strerror(err));
3439        }
3440    }
3441    }
3442#endif
3443
3444    for (i = 0; i < numVarsi++) {
3445 canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
3446        assert(var_rank[i] <= MAX_RANK);
3447        assert(var_nels[i] <= MAX_NELS);
3448        err = nc_put_var_uchar(BAD_IDivalue);
3449        IF (err != NC_EBADID)
3450     error("bad ncid: status = %d", err);
3451        err = nc_put_var_uchar(ncidBAD_VARIDvalue);
3452        IF (err != NC_ENOTVAR)
3453     error("bad var id: status = %d", err);
3454
3455 nels = 1;
3456 for (j = 0; j < var_rank[i]; j++) {
3457     nels *= var_shape[i][j];
3458 }
3459 for (allInExtRange = 1, j = 0; j < nelsj++) {
3460     err = toMixedBase(jvar_rank[i], var_shape[i], index);
3461     IF (err)
3462 error("error in toMixedBase 1");
3463     value[j]= hash_uchar(var_type[i], var_rank[i], indexNCT_UCHAR);
3464     allInExtRange = allInExtRange
3465 && inRange3(value[j], var_type[i], NCT_UCHAR);
3466 }
3467        err = nc_put_var_uchar(ncidivalue);
3468 if (canConvert) {
3469     if (allInExtRange) {
3470 IF (err)
3471     error("%s", nc_strerror(err));
3472     } else {
3473 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
3474     error("range error: status = %d", err);
3475     }
3476 } else {       /* should flag wrong type even if nothing to write */
3477     IF (nels > 0 && err != NC_ECHAR)
3478 error("wrong type: status = %d", err);
3479 }
3480    }
3481
3482        /* Preceding has written nothing for record variables, now try */
3483        /* again with more than 0 records */
3484
3485 /* Write record number NRECS to force writing of preceding records */
3486 /* Assumes variable cr is char vector with UNLIMITED dimension */
3487    err = nc_inq_varid(ncid, "cr", &varid);
3488    IF (err)
3489        error("nc_inq_varid: %s", nc_strerror(err));
3490    index[0] = NRECS-1;
3491    err = nc_put_var1_text(ncidvaridindex, "x");
3492    IF (err)
3493        error("nc_put_var1_text: %s", nc_strerror(err));
3494
3495    for (i = 0; i < numVarsi++) {
3496        if (var_dimid[i][0] == RECDIM) {  /* only test record variables here */
3497     canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
3498     assert(var_rank[i] <= MAX_RANK);
3499     assert(var_nels[i] <= MAX_NELS);
3500     err = nc_put_var_uchar(BAD_IDivalue);
3501     IF (err != NC_EBADID)
3502         error("bad ncid: status = %d", err);
3503     nels = 1;
3504     for (j = 0; j < var_rank[i]; j++) {
3505 nels *= var_shape[i][j];
3506     }
3507     for (allInExtRange = 1, j = 0; j < nelsj++) {
3508 err = toMixedBase(jvar_rank[i], var_shape[i], index);
3509 IF (err)
3510     error("error in toMixedBase 1");
3511 value[j]= hash_uchar(var_type[i], var_rank[i], indexNCT_UCHAR);
3512 allInExtRange = allInExtRange
3513     && inRange3(value[j], var_type[i], NCT_UCHAR);
3514     }
3515     err = nc_put_var_uchar(ncidivalue);
3516     if (canConvert) {
3517 if (allInExtRange) {
3518     IF (err)
3519 error("%s", nc_strerror(err));
3520 } else {
3521     IF (err != NC_ERANGE)
3522 error("range error: status = %d", err);
3523 }
3524     } else {
3525 IF (nels > 0 && err != NC_ECHAR)
3526     error("wrong type: status = %d", err);
3527     }
3528        }
3529    }
3530
3531    err = nc_close(ncid);
3532    IF (err)
3533 error("nc_close: %s", nc_strerror(err));
3534
3535    check_vars_uchar(scratch);
3536
3537    err = remove(scratch);
3538    IF (err)
3539        error("remove of %s failed", scratch);
3540}
3541
3542void
3543test_nc_put_var_schar(void)
3544{
3545    int ncid;
3546    int varid;
3547    int i;
3548    int j;
3549    int err;
3550    int nels;
3551    size_t index[MAX_RANK];
3552    int canConvert; /* Both text or both numeric */
3553    int allInExtRange; /* all values within external range? */
3554    schar value[MAX_NELS];
3555
3556    err = file_create(scratchNC_CLOBBER, &ncid);
3557    IF (err) {
3558        error("nc_create: %s", nc_strerror(err));
3559        return;
3560    }
3561    def_dims(ncid);
3562    def_vars(ncid);
3563    err = nc_enddef(ncid);
3564    IF (err)
3565        error("nc_enddef: %s", nc_strerror(err));
3566
3567#ifdef USE_PNETCDF
3568    {
3569    int format;
3570    nc_inq_format_extended(ncid, &formatNULL);
3571    if (format == NC_FORMATX_PNETCDF) {
3572        for (i = 0; i < numVarsi++) {
3573            err = nc_var_par_access(ncidiNC_COLLECTIVE);
3574     IF (err)
3575         error("nc_var_par_access: %s", nc_strerror(err));
3576        }
3577    }
3578    }
3579#endif
3580
3581    for (i = 0; i < numVarsi++) {
3582 canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
3583        assert(var_rank[i] <= MAX_RANK);
3584        assert(var_nels[i] <= MAX_NELS);
3585        err = nc_put_var_schar(BAD_IDivalue);
3586        IF (err != NC_EBADID)
3587     error("bad ncid: status = %d", err);
3588        err = nc_put_var_schar(ncidBAD_VARIDvalue);
3589        IF (err != NC_ENOTVAR)
3590     error("bad var id: status = %d", err);
3591
3592 nels = 1;
3593 for (j = 0; j < var_rank[i]; j++) {
3594     nels *= var_shape[i][j];
3595 }
3596 for (allInExtRange = 1, j = 0; j < nelsj++) {
3597     err = toMixedBase(jvar_rank[i], var_shape[i], index);
3598     IF (err)
3599 error("error in toMixedBase 1");
3600     value[j]= hash_schar(var_type[i], var_rank[i], indexNCT_SCHAR);
3601     allInExtRange = allInExtRange
3602 && inRange3(value[j], var_type[i], NCT_SCHAR);
3603 }
3604        err = nc_put_var_schar(ncidivalue);
3605 if (canConvert) {
3606     if (allInExtRange) {
3607 IF (err)
3608     error("%s", nc_strerror(err));
3609     } else {
3610 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
3611     error("range error: status = %d", err);
3612     }
3613 } else {       /* should flag wrong type even if nothing to write */
3614     IF (nels > 0 && err != NC_ECHAR)
3615 error("wrong type: status = %d", err);
3616 }
3617    }
3618
3619        /* Preceding has written nothing for record variables, now try */
3620        /* again with more than 0 records */
3621
3622 /* Write record number NRECS to force writing of preceding records */
3623 /* Assumes variable cr is char vector with UNLIMITED dimension */
3624    err = nc_inq_varid(ncid, "cr", &varid);
3625    IF (err)
3626        error("nc_inq_varid: %s", nc_strerror(err));
3627    index[0] = NRECS-1;
3628    err = nc_put_var1_text(ncidvaridindex, "x");
3629    IF (err)
3630        error("nc_put_var1_text: %s", nc_strerror(err));
3631
3632    for (i = 0; i < numVarsi++) {
3633        if (var_dimid[i][0] == RECDIM) {  /* only test record variables here */
3634     canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
3635     assert(var_rank[i] <= MAX_RANK);
3636     assert(var_nels[i] <= MAX_NELS);
3637     err = nc_put_var_schar(BAD_IDivalue);
3638     IF (err != NC_EBADID)
3639         error("bad ncid: status = %d", err);
3640     nels = 1;
3641     for (j = 0; j < var_rank[i]; j++) {
3642 nels *= var_shape[i][j];
3643     }
3644     for (allInExtRange = 1, j = 0; j < nelsj++) {
3645 err = toMixedBase(jvar_rank[i], var_shape[i], index);
3646 IF (err)
3647     error("error in toMixedBase 1");
3648 value[j]= hash_schar(var_type[i], var_rank[i], indexNCT_SCHAR);
3649 allInExtRange = allInExtRange
3650     && inRange3(value[j], var_type[i], NCT_SCHAR);
3651     }
3652     err = nc_put_var_schar(ncidivalue);
3653     if (canConvert) {
3654 if (allInExtRange) {
3655     IF (err)
3656 error("%s", nc_strerror(err));
3657 } else {
3658     IF (err != NC_ERANGE)
3659 error("range error: status = %d", err);
3660 }
3661     } else {
3662 IF (nels > 0 && err != NC_ECHAR)
3663     error("wrong type: status = %d", err);
3664     }
3665        }
3666    }
3667
3668    err = nc_close(ncid);
3669    IF (err)
3670 error("nc_close: %s", nc_strerror(err));
3671
3672    check_vars_schar(scratch);
3673
3674    err = remove(scratch);
3675    IF (err)
3676        error("remove of %s failed", scratch);
3677}
3678
3679void
3680test_nc_put_var_short(void)
3681{
3682    int ncid;
3683    int varid;
3684    int i;
3685    int j;
3686    int err;
3687    int nels;
3688    size_t index[MAX_RANK];
3689    int canConvert; /* Both text or both numeric */
3690    int allInExtRange; /* all values within external range? */
3691    short value[MAX_NELS];
3692
3693    err = file_create(scratchNC_CLOBBER, &ncid);
3694    IF (err) {
3695        error("nc_create: %s", nc_strerror(err));
3696        return;
3697    }
3698    def_dims(ncid);
3699    def_vars(ncid);
3700    err = nc_enddef(ncid);
3701    IF (err)
3702        error("nc_enddef: %s", nc_strerror(err));
3703
3704#ifdef USE_PNETCDF
3705    {
3706    int format;
3707    nc_inq_format_extended(ncid, &formatNULL);
3708    if (format == NC_FORMATX_PNETCDF) {
3709        for (i = 0; i < numVarsi++) {
3710            err = nc_var_par_access(ncidiNC_COLLECTIVE);
3711     IF (err)
3712         error("nc_var_par_access: %s", nc_strerror(err));
3713        }
3714    }
3715    }
3716#endif
3717
3718    for (i = 0; i < numVarsi++) {
3719 canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
3720        assert(var_rank[i] <= MAX_RANK);
3721        assert(var_nels[i] <= MAX_NELS);
3722        err = nc_put_var_short(BAD_IDivalue);
3723        IF (err != NC_EBADID)
3724     error("bad ncid: status = %d", err);
3725        err = nc_put_var_short(ncidBAD_VARIDvalue);
3726        IF (err != NC_ENOTVAR)
3727     error("bad var id: status = %d", err);
3728
3729 nels = 1;
3730 for (j = 0; j < var_rank[i]; j++) {
3731     nels *= var_shape[i][j];
3732 }
3733 for (allInExtRange = 1, j = 0; j < nelsj++) {
3734     err = toMixedBase(jvar_rank[i], var_shape[i], index);
3735     IF (err)
3736 error("error in toMixedBase 1");
3737     value[j]= hash_short(var_type[i], var_rank[i], indexNCT_SHORT);
3738     allInExtRange = allInExtRange
3739 && inRange3(value[j], var_type[i], NCT_SHORT);
3740 }
3741        err = nc_put_var_short(ncidivalue);
3742 if (canConvert) {
3743     if (allInExtRange) {
3744 IF (err)
3745     error("%s", nc_strerror(err));
3746     } else {
3747 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
3748     error("range error: status = %d", err);
3749     }
3750 } else {       /* should flag wrong type even if nothing to write */
3751     IF (nels > 0 && err != NC_ECHAR)
3752 error("wrong type: status = %d", err);
3753 }
3754    }
3755
3756        /* Preceding has written nothing for record variables, now try */
3757        /* again with more than 0 records */
3758
3759 /* Write record number NRECS to force writing of preceding records */
3760 /* Assumes variable cr is char vector with UNLIMITED dimension */
3761    err = nc_inq_varid(ncid, "cr", &varid);
3762    IF (err)
3763        error("nc_inq_varid: %s", nc_strerror(err));
3764    index[0] = NRECS-1;
3765    err = nc_put_var1_text(ncidvaridindex, "x");
3766    IF (err)
3767        error("nc_put_var1_text: %s", nc_strerror(err));
3768
3769    for (i = 0; i < numVarsi++) {
3770        if (var_dimid[i][0] == RECDIM) {  /* only test record variables here */
3771     canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
3772     assert(var_rank[i] <= MAX_RANK);
3773     assert(var_nels[i] <= MAX_NELS);
3774     err = nc_put_var_short(BAD_IDivalue);
3775     IF (err != NC_EBADID)
3776         error("bad ncid: status = %d", err);
3777     nels = 1;
3778     for (j = 0; j < var_rank[i]; j++) {
3779 nels *= var_shape[i][j];
3780     }
3781     for (allInExtRange = 1, j = 0; j < nelsj++) {
3782 err = toMixedBase(jvar_rank[i], var_shape[i], index);
3783 IF (err)
3784     error("error in toMixedBase 1");
3785 value[j]= hash_short(var_type[i], var_rank[i], indexNCT_SHORT);
3786 allInExtRange = allInExtRange
3787     && inRange3(value[j], var_type[i], NCT_SHORT);
3788     }
3789     err = nc_put_var_short(ncidivalue);
3790     if (canConvert) {
3791 if (allInExtRange) {
3792     IF (err)
3793 error("%s", nc_strerror(err));
3794 } else {
3795     IF (err != NC_ERANGE)
3796 error("range error: status = %d", err);
3797 }
3798     } else {
3799 IF (nels > 0 && err != NC_ECHAR)
3800     error("wrong type: status = %d", err);
3801     }
3802        }
3803    }
3804
3805    err = nc_close(ncid);
3806    IF (err)
3807 error("nc_close: %s", nc_strerror(err));
3808
3809    check_vars_short(scratch);
3810
3811    err = remove(scratch);
3812    IF (err)
3813        error("remove of %s failed", scratch);
3814}
3815
3816void
3817test_nc_put_var_int(void)
3818{
3819    int ncid;
3820    int varid;
3821    int i;
3822    int j;
3823    int err;
3824    int nels;
3825    size_t index[MAX_RANK];
3826    int canConvert; /* Both text or both numeric */
3827    int allInExtRange; /* all values within external range? */
3828    int value[MAX_NELS];
3829
3830    err = file_create(scratchNC_CLOBBER, &ncid);
3831    IF (err) {
3832        error("nc_create: %s", nc_strerror(err));
3833        return;
3834    }
3835    def_dims(ncid);
3836    def_vars(ncid);
3837    err = nc_enddef(ncid);
3838    IF (err)
3839        error("nc_enddef: %s", nc_strerror(err));
3840
3841#ifdef USE_PNETCDF
3842    {
3843    int format;
3844    nc_inq_format_extended(ncid, &formatNULL);
3845    if (format == NC_FORMATX_PNETCDF) {
3846        for (i = 0; i < numVarsi++) {
3847            err = nc_var_par_access(ncidiNC_COLLECTIVE);
3848     IF (err)
3849         error("nc_var_par_access: %s", nc_strerror(err));
3850        }
3851    }
3852    }
3853#endif
3854
3855    for (i = 0; i < numVarsi++) {
3856 canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
3857        assert(var_rank[i] <= MAX_RANK);
3858        assert(var_nels[i] <= MAX_NELS);
3859        err = nc_put_var_int(BAD_IDivalue);
3860        IF (err != NC_EBADID)
3861     error("bad ncid: status = %d", err);
3862        err = nc_put_var_int(ncidBAD_VARIDvalue);
3863        IF (err != NC_ENOTVAR)
3864     error("bad var id: status = %d", err);
3865
3866 nels = 1;
3867 for (j = 0; j < var_rank[i]; j++) {
3868     nels *= var_shape[i][j];
3869 }
3870 for (allInExtRange = 1, j = 0; j < nelsj++) {
3871     err = toMixedBase(jvar_rank[i], var_shape[i], index);
3872     IF (err)
3873 error("error in toMixedBase 1");
3874     value[j]= hash_int(var_type[i], var_rank[i], indexNCT_INT);
3875     allInExtRange = allInExtRange
3876 && inRange3(value[j], var_type[i], NCT_INT);
3877 }
3878        err = nc_put_var_int(ncidivalue);
3879 if (canConvert) {
3880     if (allInExtRange) {
3881 IF (err)
3882     error("%s", nc_strerror(err));
3883     } else {
3884 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
3885     error("range error: status = %d", err);
3886     }
3887 } else {       /* should flag wrong type even if nothing to write */
3888     IF (nels > 0 && err != NC_ECHAR)
3889 error("wrong type: status = %d", err);
3890 }
3891    }
3892
3893        /* Preceding has written nothing for record variables, now try */
3894        /* again with more than 0 records */
3895
3896 /* Write record number NRECS to force writing of preceding records */
3897 /* Assumes variable cr is char vector with UNLIMITED dimension */
3898    err = nc_inq_varid(ncid, "cr", &varid);
3899    IF (err)
3900        error("nc_inq_varid: %s", nc_strerror(err));
3901    index[0] = NRECS-1;
3902    err = nc_put_var1_text(ncidvaridindex, "x");
3903    IF (err)
3904        error("nc_put_var1_text: %s", nc_strerror(err));
3905
3906    for (i = 0; i < numVarsi++) {
3907        if (var_dimid[i][0] == RECDIM) {  /* only test record variables here */
3908     canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
3909     assert(var_rank[i] <= MAX_RANK);
3910     assert(var_nels[i] <= MAX_NELS);
3911     err = nc_put_var_int(BAD_IDivalue);
3912     IF (err != NC_EBADID)
3913         error("bad ncid: status = %d", err);
3914     nels = 1;
3915     for (j = 0; j < var_rank[i]; j++) {
3916 nels *= var_shape[i][j];
3917     }
3918     for (allInExtRange = 1, j = 0; j < nelsj++) {
3919 err = toMixedBase(jvar_rank[i], var_shape[i], index);
3920 IF (err)
3921     error("error in toMixedBase 1");
3922 value[j]= hash_int(var_type[i], var_rank[i], indexNCT_INT);
3923 allInExtRange = allInExtRange
3924     && inRange3(value[j], var_type[i], NCT_INT);
3925     }
3926     err = nc_put_var_int(ncidivalue);
3927     if (canConvert) {
3928 if (allInExtRange) {
3929     IF (err)
3930 error("%s", nc_strerror(err));
3931 } else {
3932     IF (err != NC_ERANGE)
3933 error("range error: status = %d", err);
3934 }
3935     } else {
3936 IF (nels > 0 && err != NC_ECHAR)
3937     error("wrong type: status = %d", err);
3938     }
3939        }
3940    }
3941
3942    err = nc_close(ncid);
3943    IF (err)
3944 error("nc_close: %s", nc_strerror(err));
3945
3946    check_vars_int(scratch);
3947
3948    err = remove(scratch);
3949    IF (err)
3950        error("remove of %s failed", scratch);
3951}
3952
3953void
3954test_nc_put_var_long(void)
3955{
3956    int ncid;
3957    int varid;
3958    int i;
3959    int j;
3960    int err;
3961    int nels;
3962    size_t index[MAX_RANK];
3963    int canConvert; /* Both text or both numeric */
3964    int allInExtRange; /* all values within external range? */
3965    long value[MAX_NELS];
3966
3967    err = file_create(scratchNC_CLOBBER, &ncid);
3968    IF (err) {
3969        error("nc_create: %s", nc_strerror(err));
3970        return;
3971    }
3972    def_dims(ncid);
3973    def_vars(ncid);
3974    err = nc_enddef(ncid);
3975    IF (err)
3976        error("nc_enddef: %s", nc_strerror(err));
3977
3978#ifdef USE_PNETCDF
3979    {
3980    int format;
3981    nc_inq_format_extended(ncid, &formatNULL);
3982    if (format == NC_FORMATX_PNETCDF) {
3983        for (i = 0; i < numVarsi++) {
3984            err = nc_var_par_access(ncidiNC_COLLECTIVE);
3985     IF (err)
3986         error("nc_var_par_access: %s", nc_strerror(err));
3987        }
3988    }
3989    }
3990#endif
3991
3992    for (i = 0; i < numVarsi++) {
3993 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
3994        assert(var_rank[i] <= MAX_RANK);
3995        assert(var_nels[i] <= MAX_NELS);
3996        err = nc_put_var_long(BAD_IDivalue);
3997        IF (err != NC_EBADID)
3998     error("bad ncid: status = %d", err);
3999        err = nc_put_var_long(ncidBAD_VARIDvalue);
4000        IF (err != NC_ENOTVAR)
4001     error("bad var id: status = %d", err);
4002
4003 nels = 1;
4004 for (j = 0; j < var_rank[i]; j++) {
4005     nels *= var_shape[i][j];
4006 }
4007 for (allInExtRange = 1, j = 0; j < nelsj++) {
4008     err = toMixedBase(jvar_rank[i], var_shape[i], index);
4009     IF (err)
4010 error("error in toMixedBase 1");
4011     value[j]= hash_long(var_type[i], var_rank[i], indexNCT_LONG);
4012     allInExtRange = allInExtRange
4013 && inRange3(value[j], var_type[i], NCT_LONG);
4014 }
4015        err = nc_put_var_long(ncidivalue);
4016 if (canConvert) {
4017     if (allInExtRange) {
4018 IF (err)
4019     error("%s", nc_strerror(err));
4020     } else {
4021 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
4022     error("range error: status = %d", err);
4023     }
4024 } else {       /* should flag wrong type even if nothing to write */
4025     IF (nels > 0 && err != NC_ECHAR)
4026 error("wrong type: status = %d", err);
4027 }
4028    }
4029
4030        /* Preceding has written nothing for record variables, now try */
4031        /* again with more than 0 records */
4032
4033 /* Write record number NRECS to force writing of preceding records */
4034 /* Assumes variable cr is char vector with UNLIMITED dimension */
4035    err = nc_inq_varid(ncid, "cr", &varid);
4036    IF (err)
4037        error("nc_inq_varid: %s", nc_strerror(err));
4038    index[0] = NRECS-1;
4039    err = nc_put_var1_text(ncidvaridindex, "x");
4040    IF (err)
4041        error("nc_put_var1_text: %s", nc_strerror(err));
4042
4043    for (i = 0; i < numVarsi++) {
4044        if (var_dimid[i][0] == RECDIM) {  /* only test record variables here */
4045     canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
4046     assert(var_rank[i] <= MAX_RANK);
4047     assert(var_nels[i] <= MAX_NELS);
4048     err = nc_put_var_long(BAD_IDivalue);
4049     IF (err != NC_EBADID)
4050         error("bad ncid: status = %d", err);
4051     nels = 1;
4052     for (j = 0; j < var_rank[i]; j++) {
4053 nels *= var_shape[i][j];
4054     }
4055     for (allInExtRange = 1, j = 0; j < nelsj++) {
4056 err = toMixedBase(jvar_rank[i], var_shape[i], index);
4057 IF (err)
4058     error("error in toMixedBase 1");
4059 value[j]= hash_long(var_type[i], var_rank[i], indexNCT_LONG);
4060 allInExtRange = allInExtRange
4061     && inRange3(value[j], var_type[i], NCT_LONG);
4062     }
4063     err = nc_put_var_long(ncidivalue);
4064     if (canConvert) {
4065 if (allInExtRange) {
4066     IF (err)
4067 error("%s", nc_strerror(err));
4068 } else {
4069     IF (err != NC_ERANGE)
4070 error("range error: status = %d", err);
4071 }
4072     } else {
4073 IF (nels > 0 && err != NC_ECHAR)
4074     error("wrong type: status = %d", err);
4075     }
4076        }
4077    }
4078
4079    err = nc_close(ncid);
4080    IF (err)
4081 error("nc_close: %s", nc_strerror(err));
4082
4083    check_vars_long(scratch);
4084
4085    err = remove(scratch);
4086    IF (err)
4087        error("remove of %s failed", scratch);
4088}
4089
4090void
4091test_nc_put_var_float(void)
4092{
4093    int ncid;
4094    int varid;
4095    int i;
4096    int j;
4097    int err;
4098    int nels;
4099    size_t index[MAX_RANK];
4100    int canConvert; /* Both text or both numeric */
4101    int allInExtRange; /* all values within external range? */
4102    float value[MAX_NELS];
4103
4104    err = file_create(scratchNC_CLOBBER, &ncid);
4105    IF (err) {
4106        error("nc_create: %s", nc_strerror(err));
4107        return;
4108    }
4109    def_dims(ncid);
4110    def_vars(ncid);
4111    err = nc_enddef(ncid);
4112    IF (err)
4113        error("nc_enddef: %s", nc_strerror(err));
4114
4115#ifdef USE_PNETCDF
4116    {
4117    int format;
4118    nc_inq_format_extended(ncid, &formatNULL);
4119    if (format == NC_FORMATX_PNETCDF) {
4120        for (i = 0; i < numVarsi++) {
4121            err = nc_var_par_access(ncidiNC_COLLECTIVE);
4122     IF (err)
4123         error("nc_var_par_access: %s", nc_strerror(err));
4124        }
4125    }
4126    }
4127#endif
4128
4129    for (i = 0; i < numVarsi++) {
4130 canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
4131        assert(var_rank[i] <= MAX_RANK);
4132        assert(var_nels[i] <= MAX_NELS);
4133        err = nc_put_var_float(BAD_IDivalue);
4134        IF (err != NC_EBADID)
4135     error("bad ncid: status = %d", err);
4136        err = nc_put_var_float(ncidBAD_VARIDvalue);
4137        IF (err != NC_ENOTVAR)
4138     error("bad var id: status = %d", err);
4139
4140 nels = 1;
4141 for (j = 0; j < var_rank[i]; j++) {
4142     nels *= var_shape[i][j];
4143 }
4144 for (allInExtRange = 1, j = 0; j < nelsj++) {
4145     err = toMixedBase(jvar_rank[i], var_shape[i], index);
4146     IF (err)
4147 error("error in toMixedBase 1");
4148     value[j]= hash_float(var_type[i], var_rank[i], indexNCT_FLOAT);
4149     allInExtRange = allInExtRange
4150 && inRange3(value[j], var_type[i], NCT_FLOAT);
4151 }
4152        err = nc_put_var_float(ncidivalue);
4153 if (canConvert) {
4154     if (allInExtRange) {
4155 IF (err)
4156     error("%s", nc_strerror(err));
4157     } else {
4158 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
4159     error("range error: status = %d", err);
4160     }
4161 } else {       /* should flag wrong type even if nothing to write */
4162     IF (nels > 0 && err != NC_ECHAR)
4163 error("wrong type: status = %d", err);
4164 }
4165    }
4166
4167        /* Preceding has written nothing for record variables, now try */
4168        /* again with more than 0 records */
4169
4170 /* Write record number NRECS to force writing of preceding records */
4171 /* Assumes variable cr is char vector with UNLIMITED dimension */
4172    err = nc_inq_varid(ncid, "cr", &varid);
4173    IF (err)
4174        error("nc_inq_varid: %s", nc_strerror(err));
4175    index[0] = NRECS-1;
4176    err = nc_put_var1_text(ncidvaridindex, "x");
4177    IF (err)
4178        error("nc_put_var1_text: %s", nc_strerror(err));
4179
4180    for (i = 0; i < numVarsi++) {
4181        if (var_dimid[i][0] == RECDIM) {  /* only test record variables here */
4182     canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
4183     assert(var_rank[i] <= MAX_RANK);
4184     assert(var_nels[i] <= MAX_NELS);
4185     err = nc_put_var_float(BAD_IDivalue);
4186     IF (err != NC_EBADID)
4187         error("bad ncid: status = %d", err);
4188     nels = 1;
4189     for (j = 0; j < var_rank[i]; j++) {
4190 nels *= var_shape[i][j];
4191     }
4192     for (allInExtRange = 1, j = 0; j < nelsj++) {
4193 err = toMixedBase(jvar_rank[i], var_shape[i], index);
4194 IF (err)
4195     error("error in toMixedBase 1");
4196 value[j]= hash_float(var_type[i], var_rank[i], indexNCT_FLOAT);
4197 allInExtRange = allInExtRange
4198     && inRange3(value[j], var_type[i], NCT_FLOAT);
4199     }
4200     err = nc_put_var_float(ncidivalue);
4201     if (canConvert) {
4202 if (allInExtRange) {
4203     IF (err)
4204 error("%s", nc_strerror(err));
4205 } else {
4206     IF (err != NC_ERANGE)
4207 error("range error: status = %d", err);
4208 }
4209     } else {
4210 IF (nels > 0 && err != NC_ECHAR)
4211     error("wrong type: status = %d", err);
4212     }
4213        }
4214    }
4215
4216    err = nc_close(ncid);
4217    IF (err)
4218 error("nc_close: %s", nc_strerror(err));
4219
4220    check_vars_float(scratch);
4221
4222    err = remove(scratch);
4223    IF (err)
4224        error("remove of %s failed", scratch);
4225}
4226
4227void
4228test_nc_put_var_double(void)
4229{
4230    int ncid;
4231    int varid;
4232    int i;
4233    int j;
4234    int err;
4235    int nels;
4236    size_t index[MAX_RANK];
4237    int canConvert; /* Both text or both numeric */
4238    int allInExtRange; /* all values within external range? */
4239    double value[MAX_NELS];
4240
4241    err = file_create(scratchNC_CLOBBER, &ncid);
4242    IF (err) {
4243        error("nc_create: %s", nc_strerror(err));
4244        return;
4245    }
4246    def_dims(ncid);
4247    def_vars(ncid);
4248    err = nc_enddef(ncid);
4249    IF (err)
4250        error("nc_enddef: %s", nc_strerror(err));
4251
4252#ifdef USE_PNETCDF
4253    {
4254    int format;
4255    nc_inq_format_extended(ncid, &formatNULL);
4256    if (format == NC_FORMATX_PNETCDF) {
4257        for (i = 0; i < numVarsi++) {
4258            err = nc_var_par_access(ncidiNC_COLLECTIVE);
4259     IF (err)
4260         error("nc_var_par_access: %s", nc_strerror(err));
4261        }
4262    }
4263    }
4264#endif
4265
4266    for (i = 0; i < numVarsi++) {
4267 canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
4268        assert(var_rank[i] <= MAX_RANK);
4269        assert(var_nels[i] <= MAX_NELS);
4270        err = nc_put_var_double(BAD_IDivalue);
4271        IF (err != NC_EBADID)
4272     error("bad ncid: status = %d", err);
4273        err = nc_put_var_double(ncidBAD_VARIDvalue);
4274        IF (err != NC_ENOTVAR)
4275     error("bad var id: status = %d", err);
4276
4277 nels = 1;
4278 for (j = 0; j < var_rank[i]; j++) {
4279     nels *= var_shape[i][j];
4280 }
4281 for (allInExtRange = 1, j = 0; j < nelsj++) {
4282     err = toMixedBase(jvar_rank[i], var_shape[i], index);
4283     IF (err)
4284 error("error in toMixedBase 1");
4285     value[j]= hash_double(var_type[i], var_rank[i], indexNCT_DOUBLE);
4286     allInExtRange = allInExtRange
4287 && inRange3(value[j], var_type[i], NCT_DOUBLE);
4288 }
4289        err = nc_put_var_double(ncidivalue);
4290 if (canConvert) {
4291     if (allInExtRange) {
4292 IF (err)
4293     error("%s", nc_strerror(err));
4294     } else {
4295 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
4296     error("range error: status = %d", err);
4297     }
4298 } else {       /* should flag wrong type even if nothing to write */
4299     IF (nels > 0 && err != NC_ECHAR)
4300 error("wrong type: status = %d", err);
4301 }
4302    }
4303
4304        /* Preceding has written nothing for record variables, now try */
4305        /* again with more than 0 records */
4306
4307 /* Write record number NRECS to force writing of preceding records */
4308 /* Assumes variable cr is char vector with UNLIMITED dimension */
4309    err = nc_inq_varid(ncid, "cr", &varid);
4310    IF (err)
4311        error("nc_inq_varid: %s", nc_strerror(err));
4312    index[0] = NRECS-1;
4313    err = nc_put_var1_text(ncidvaridindex, "x");
4314    IF (err)
4315        error("nc_put_var1_text: %s", nc_strerror(err));
4316
4317    for (i = 0; i < numVarsi++) {
4318        if (var_dimid[i][0] == RECDIM) {  /* only test record variables here */
4319     canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
4320     assert(var_rank[i] <= MAX_RANK);
4321     assert(var_nels[i] <= MAX_NELS);
4322     err = nc_put_var_double(BAD_IDivalue);
4323     IF (err != NC_EBADID)
4324         error("bad ncid: status = %d", err);
4325     nels = 1;
4326     for (j = 0; j < var_rank[i]; j++) {
4327 nels *= var_shape[i][j];
4328     }
4329     for (allInExtRange = 1, j = 0; j < nelsj++) {
4330 err = toMixedBase(jvar_rank[i], var_shape[i], index);
4331 IF (err)
4332     error("error in toMixedBase 1");
4333 value[j]= hash_double(var_type[i], var_rank[i], indexNCT_DOUBLE);
4334 allInExtRange = allInExtRange
4335     && inRange3(value[j], var_type[i], NCT_DOUBLE);
4336     }
4337     err = nc_put_var_double(ncidivalue);
4338     if (canConvert) {
4339 if (allInExtRange) {
4340     IF (err)
4341 error("%s", nc_strerror(err));
4342 } else {
4343     IF (err != NC_ERANGE)
4344 error("range error: status = %d", err);
4345 }
4346     } else {
4347 IF (nels > 0 && err != NC_ECHAR)
4348     error("wrong type: status = %d", err);
4349     }
4350        }
4351    }
4352
4353    err = nc_close(ncid);
4354    IF (err)
4355 error("nc_close: %s", nc_strerror(err));
4356
4357    check_vars_double(scratch);
4358
4359    err = remove(scratch);
4360    IF (err)
4361        error("remove of %s failed", scratch);
4362}
4363
4364void
4365test_nc_put_var_ushort(void)
4366{
4367    int ncid;
4368    int varid;
4369    int i;
4370    int j;
4371    int err;
4372    int nels;
4373    size_t index[MAX_RANK];
4374    int canConvert; /* Both text or both numeric */
4375    int allInExtRange; /* all values within external range? */
4376    ushort value[MAX_NELS];
4377
4378    err = file_create(scratchNC_CLOBBER, &ncid);
4379    IF (err) {
4380        error("nc_create: %s", nc_strerror(err));
4381        return;
4382    }
4383    def_dims(ncid);
4384    def_va