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