1/* This is part of the netCDF package.
2   Copyright 2005 University Corporation for Atmospheric Research/Unidata
3    See COPYRIGHT file for conditions of use.
4
5   Test netcdf-4 variables.
6   $Id: tst_vars2.c,v 1.35 2010/01/25 21:01:08 ed Exp $
7*/
8
9#include <nc_tests.h>
10#include "err_macros.h"
11#include "netcdf.h"
12
13#define FILE_NAME "tst_vars2.nc"
14#define NUM_DIMS 1
15#define DIM1_LEN NC_UNLIMITED
16#define DIM1_NAME "Hoplites_Engaged"
17#define VAR_NAME "Battle_of_Marathon"
18#define LOSSES_NAME "Miltiades_Losses"
19
20#define MAX_CNUM 4
21
22int
23main(int argc, char **argv)
24{
25   int nciddimids[NUM_DIMS];
26   int varid;
27   int nvars_invarids_in[NUM_DIMS];
28   signed char fill_value = 42, fill_value_in;
29   nc_type xtype_in;
30   size_t len_in;
31   char name_in[NC_MAX_NAME + 1];
32   int attnum_in;
33   int cnum;
34
35   printf("\n*** Testing netcdf-4 variable functions, even more.\n");
36   for (cnum = 0; cnum < MAX_CNUMcnum++)
37   {
38      int cmode = 0;
39
40      switch(cnum)
41      {
42         case 0:
43            printf("*** Testing with classic format:\n");
44            cmode = 0;
45            break;
46         case 1:
47            printf("*** Testing with 64-bit offset format:\n");
48            cmode = NC_64BIT_OFFSET;
49            break;
50         case 2:
51            printf("*** Testing with HDF5:\n");
52            cmode = NC_NETCDF4|NC_CLOBBER;
53            break;
54         case 3:
55            printf("*** Testing with HDF5, netCDF Classic Model:\n");
56            cmode = NC_CLASSIC_MODEL | NC_NETCDF4;
57     break;
58  default:
59     return 1;
60      }
61
62      printf("**** testing simple fill value attribute creation...");
63      {
64         /* Create a netcdf-4 file with one scalar var. Add fill
65          * value. */
66         if (nc_create(FILE_NAMEcmode, &ncid)) ERR;
67         if (nc_def_var(ncidVAR_NAMENC_BYTE, 0, NULL, &varid)) ERR;
68         if (nc_enddef(ncid)) ERR;
69         if (nc_redef(ncid)) ERR;
70         if (nc_put_att_schar(ncidvarid_FillValueNC_BYTE, 1, &fill_value)) ERR;
71         if (nc_close(ncid)) ERR;
72
73         /* Open the file and check. */
74         if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
75         if (nc_inq_varids(ncid, &nvars_invarids_in)) ERR;
76         if (nvars_in != 1 || varids_in[0] != 0) ERR;
77         if (nc_inq_varname(ncid, 0, name_in)) ERR;
78         if (strcmp(name_inVAR_NAME)) ERR;
79         if (nc_inq_att(ncidvarid_FillValue, &xtype_in, &len_in)) ERR;
80         if (xtype_in != NC_BYTE || len_in != 1) ERR;
81         if (nc_get_att(ncidvarid_FillValue, &fill_value_in)) ERR;
82         if (fill_value_in != fill_valueERR;
83         if (nc_close(ncid)) ERR;
84      }
85
86      SUMMARIZE_ERR;
87      printf("**** testing simple fill value with data read...");
88      {
89         size_t start[NUM_DIMS], count[NUM_DIMS];
90         signed char data = 99, data_in;
91
92         /* Create a netcdf-4 file with one unlimited dim and one
93          * var. Add fill value. */
94         if (nc_create(FILE_NAMEcmode, &ncid)) ERR;
95         if (nc_def_dim(ncidDIM1_NAMEDIM1_LEN, &dimids[0])) ERR;
96         if (nc_def_var(ncidVAR_NAMENC_BYTENUM_DIMSdimids, &varid)) ERR;
97         if (nc_enddef(ncid)) ERR;
98         if (nc_redef(ncid)) ERR;
99         if (nc_put_att_schar(ncidvarid_FillValueNC_BYTE, 1, &fill_value)) ERR;
100         if (nc_enddef(ncid)) ERR;
101
102         /* Write the second record. */
103         start[0] = 1;
104         count[0] = 1;
105         if (nc_put_vara_schar(ncidvaridstartcount, &data)) ERR;
106
107         /* Read the first record, it should be the fill value. */
108         start[0] = 0;
109         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
110         if (data_in != fill_valueERR;
111
112         /* Read the second record, it should be the value we just wrote
113          * there. */
114         start[0] = 1;
115         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
116         if (data_in != dataERR;
117
118         /* Close up. */
119         if (nc_close(ncid)) ERR;
120
121         /* Open the file and check. */
122         if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
123
124         /* Check metadata. */
125         if (nc_inq_varids(ncid, &nvars_invarids_in)) ERR;
126         if (nvars_in != 1 || varids_in[0] != 0) ERR;
127         if (nc_inq_varname(ncid, 0, name_in)) ERR;
128         if (strcmp(name_inVAR_NAME)) ERR;
129
130         /* Check fill value att. */
131         if (nc_inq_att(ncidvarid_FillValue, &xtype_in, &len_in)) ERR;
132         if (xtype_in != NC_BYTE || len_in != 1) ERR;
133         if (nc_get_att(ncidvarid_FillValue, &fill_value_in)) ERR;
134         if (fill_value_in != fill_valueERR;
135
136         /* Read the first record, it should be the fill value. */
137         start[0] = 0;
138         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
139         if (data_in != fill_valueERR;
140
141         /* Read the second record, it should be the value we just wrote
142          * there. */
143         start[0] = 1;
144         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
145         if (data_in != dataERR;
146
147         if (nc_close(ncid)) ERR;
148      }
149
150      SUMMARIZE_ERR;
151      printf("**** testing fill value with one other attribute...");
152
153      {
154         int losses_value = 192, losses_value_in;
155
156         /* Create a netcdf-4 file with one dim and one var. Add another
157          * attribute, then fill value. */
158         if (nc_create(FILE_NAMEcmode, &ncid)) ERR;
159         if (nc_def_dim(ncidDIM1_NAMEDIM1_LEN, &dimids[0])) ERR;
160         if (nc_def_var(ncidVAR_NAMENC_BYTENUM_DIMSdimids, &varid)) ERR;
161         if (nc_put_att_int(ncidvaridLOSSES_NAMENC_INT, 1, &losses_value)) ERR;
162         if (nc_put_att_schar(ncidvarid_FillValueNC_BYTE, 1, &fill_value)) ERR;
163         if (nc_close(ncid)) ERR;
164
165         /* Open the file and check. */
166         if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
167         if (nc_inq_att(ncid, 0, LOSSES_NAME, &xtype_in, &len_in)) ERR;
168         if (xtype_in != NC_INT || len_in != 1) ERR;
169         if (nc_get_att(ncid, 0, LOSSES_NAME, &losses_value_in)) ERR;
170         if (losses_value_in != losses_valueERR;
171         if (nc_inq_att(ncid, 0, _FillValue, &xtype_in, &len_in)) ERR;
172         if (xtype_in != NC_BYTE || len_in != 1) ERR;
173         if (nc_get_att(ncid, 0, _FillValue, &fill_value_in)) ERR;
174         if (fill_value_in != fill_valueERR;
175         if (nc_inq_attid(ncid, 0, LOSSES_NAME, &attnum_in)) ERR;
176         if (attnum_in != 0) ERR;
177         if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR;
178         if (attnum_in != 1) ERR;
179         if (nc_close(ncid)) ERR;
180      }
181
182      SUMMARIZE_ERR;
183      printf("**** testing fill value with three other attributes...");
184      {
185#define NUM_LEADERS 3
186         char leader[NUM_LEADERS][NC_MAX_NAME + 1] = {"hair_length_of_strategoi",
187                                                      "hair_length_of_Miltiades",
188                                                      "hair_length_of_Darius_I"};
189         short hair_length[NUM_LEADERS] = {3, 11, 4};
190         short short_in;
191         int a;
192
193         /* Create a netcdf file with one dim and one var. Add 3
194          * attributes, then fill value. */
195         if (nc_create(FILE_NAMEcmode, &ncid)) ERR;
196         if (nc_def_dim(ncidDIM1_NAMEDIM1_LEN, &dimids[0])) ERR;
197         if (nc_def_var(ncidVAR_NAMENC_BYTENUM_DIMSdimids, &varid)) ERR;
198         for (a = 0; a < NUM_LEADERSa++)
199            if (nc_put_att_short(ncidvaridleader[a], NC_SHORT, 1, &hair_length[a])) ERR;
200         if (nc_put_att_schar(ncidvarid_FillValueNC_BYTE, 1, &fill_value)) ERR;
201         if (nc_close(ncid)) ERR;
202
203         /* Open the file. */
204         if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
205
206         /* Check our three hair-related attributes. */
207         for (a = 0; a < NUM_LEADERSa++)
208         {
209            if (nc_inq_att(ncid, 0, leader[a], &xtype_in, &len_in)) ERR;
210            if (xtype_in != NC_SHORT || len_in != 1) ERR;
211            if (nc_get_att(ncid, 0, leader[a], &short_in)) ERR;
212            if (short_in != hair_length[a]) ERR;
213            if (nc_inq_attid(ncid, 0, leader[a], &attnum_in)) ERR;
214            if (attnum_in != aERR;
215         }
216
217         /* Check our fill value attribute. */
218         if (nc_inq_att(ncid, 0, _FillValue, &xtype_in, &len_in)) ERR;
219         if (xtype_in != NC_BYTE || len_in != 1) ERR;
220         if (nc_get_att(ncid, 0, _FillValue, &fill_value_in)) ERR;
221         if (fill_value_in != fill_valueERR;
222
223         if (nc_close(ncid)) ERR;
224      }
225
226      SUMMARIZE_ERR;
227      printf("**** testing fill value with simple example...");
228      {
229/* Dims stuff. */
230#define NDIMS 3
231#define VAR_DIMS 3
232#define DIM_A "dim1"
233#define DIM_A_LEN 4
234#define DIM_B "dim2"
235#define DIM_B_LEN 3
236#define DIM_C "dim3"
237#define DIM_C_LEN NC_UNLIMITED
238
239/* Var stuff. */
240#define CXX_VAR_NAME "P"
241
242/* Att stuff. */
243#define NUM_ATTS 4
244#define LONG_NAME "long_name"
245#define PRES_MAX_WIND "pressure at maximum wind"
246#define UNITS "units"
247#define HECTOPASCALS "hectopascals"
248
249         int dimid[NDIMS], var_dimids[VAR_DIMS] = {2, 1, 0};
250         float fill_value = -9999.0f;
251         char long_name[] = PRES_MAX_WIND;
252
253         if (nc_create(FILE_NAMEcmode, &ncid)) ERR;
254
255         /* Create dims. */
256         if (nc_def_dim(ncidDIM_ADIM_A_LEN, &dimid[0])) ERR;
257         if (nc_def_dim (ncidDIM_BDIM_B_LEN, &dimid[1])) ERR;
258         if (nc_def_dim(ncidDIM_CDIM_C_LEN, &dimid[2])) ERR;
259
260         /* Create var. */
261         if (nc_def_var(ncidCXX_VAR_NAMENC_FLOATVAR_DIMS,
262                        var_dimids, &varid)) ERR;
263         if (varidERR;
264
265         if (nc_put_att(ncidvaridLONG_NAMENC_CHAR, strlen(long_name) + 1,
266                        long_name)) ERR;
267         if (nc_put_att(ncidvaridUNITSNC_CHAR, strlen(UNITS) + 1,
268                        UNITS)) ERR;
269
270         /* Check to ensure the atts have their expected attnums. */
271         if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR;
272         if (attnum_in != 0) ERR;
273         if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR;
274         if (attnum_in != 1) ERR;
275
276         /* Now add a fill value. This will acutually cause HDF5 to
277          * destroy the dataset and recreate it, recreating also the
278          * three attributes that are attached to it. */
279         if (nc_put_att(ncidvarid_FillValueNC_FLOAT,
280                        1, &fill_value)) ERR;
281
282         /* Check to ensure the atts have their expected attnums. */
283         if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR;
284         if (attnum_in != 0) ERR;
285         if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR;
286         if (attnum_in != 1) ERR;
287
288         if (nc_close(ncid)) ERR;
289
290         /* Open the file and check. */
291         if (nc_open(FILE_NAME, 0, &ncid)) ERR;
292         if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR;
293         if (attnum_in != 0) ERR;
294         if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR;
295         if (attnum_in != 1) ERR;
296         if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR;
297         if (attnum_in != 2) ERR;
298
299         if (nc_close(ncid)) ERR;
300      }
301      SUMMARIZE_ERR;
302
303#ifndef NO_NETCDF_2
304      /* The following test is an attempt to recreate a problem occurring
305         in the cxx tests. The file is created in c++ in nctsts.cpp. */
306      printf("**** testing fill value with example from cxx tests in v2 api...");
307      {
308/* Dims stuff. */
309#define NDIMS_1 4
310#define VAR_DIMS 3
311#define LAT "lat"
312#define LAT_LEN 4
313#define LON "lon"
314#define LON_LEN 3
315#define FRTIMED "frtimed"
316#define FRTIMED_LEN NC_UNLIMITED
317#define TIMELEN "timelen"
318#define TIMELEN_LEN 20
319
320/* Var stuff. */
321#define CXX_VAR_NAME "P"
322
323/* Att stuff. */
324#define NUM_ATTS 4
325#define LONG_NAME "long_name"
326#define UNITS "units"
327
328         int dimid[NDIMS_1], var_dimids[VAR_DIMS] = {2, 0, 1};
329         float fill_value = -9999.0f;
330         char long_name[] = PRES_MAX_WIND;
331         int iattid[NUM_ATTS];
332
333         ncid = nccreate(FILE_NAMENC_NETCDF4);
334
335         /* Create dims. */
336         dimid[0] = ncdimdef(ncidLATLAT_LEN);
337         dimid[1] = ncdimdef(ncidLONLON_LEN);
338         dimid[2] = ncdimdef(ncidFRTIMEDFRTIMED_LEN);
339         dimid[3] = ncdimdef(ncidTIMELENTIMELEN_LEN);
340
341         /* Just check our dimids to see that they are correct. */
342         for (i = 0; i < NDIMS_1i++)
343            if (dimid[i] != iERR;
344
345         /* Create var. */
346         varid = ncvardef(ncidCXX_VAR_NAMENC_FLOATVAR_DIMSvar_dimids);
347         if (varidERR;
348
349         /* Add three atts to the var, long_name, units, and
350          * valid_range. */
351         if (nc_put_att(ncidvaridLONG_NAMENC_CHAR, strlen(long_name) + 1,
352                        long_name)) ERR;
353         if (nc_put_att(ncidvaridUNITSNC_CHAR, strlen(UNITS) + 1,
354                        UNITS)) ERR;
355
356         /* Check to ensure the atts have their expected attnums. */
357         if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR;
358         if (attnum_in != 0) ERR;
359         if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR;
360         if (attnum_in != 1) ERR;
361
362         /* Now add a fill value. This will acutually cause HDF5 to
363          * destroy the dataset and recreate it, recreating also the
364          * three attributes that are attached to it. */
365         attid[3] = ncattput(ncidvarid_FillValueNC_FLOAT,
366                             1, &fill_value);
367
368         /* Check to ensure the atts have their expected attnums. */
369         if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR;
370         if (attnum_in != 0) ERR;
371         if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR;
372         if (attnum_in != 1) ERR;
373         if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR;
374         if (attnum_in != 2) ERR;
375
376         ncclose(ncid);
377
378         /* Open the file and check. */
379         ncid = ncopen(FILE_NAME, 0);
380         if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR;
381         if (attnum_in != 0) ERR;
382         if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR;
383         if (attnum_in != 1) ERR;
384         if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR;
385         if (attnum_in != 2) ERR;
386         ncclose(ncid);
387      }
388      SUMMARIZE_ERR;
389#endif /* NO_NETCDF_2 */
390   }
391
392   printf("**** testing create order varids...");
393
394#define UNITS "units"
395#define DIMNAME "x"
396#define VARNAME "data"
397   {
398      /* This test contributed by Jeff Whitaker of NOAA - Thanks Jeff! */
399      int nciddimidvaridxvarid;
400      char units[] = "zlotys";
401
402      if (nc_create(FILE_NAMENC_NETCDF4|NC_CLASSIC_MODEL, &ncid)) ERR;
403      if (nc_def_dim(ncidDIMNAME, 1, &dimid)) ERR;
404      if (nc_enddef(ncid)) ERR;
405      if (nc_redef(ncid)) ERR;
406      if (nc_def_var(ncidDIMNAMENC_INT, 1, &dimid, &xvarid)) ERR;
407      if (nc_put_att_text(ncidxvaridUNITS, strlen(units), units)) ERR;
408      if (nc_def_var(ncidVARNAMENC_INT, 1, &dimid, &varid)) ERR;
409      if (nc_close(ncid)) ERR;
410
411      if (nc_open(FILE_NAME, 0, &ncid)) ERR;
412      if (nc_close(ncid)) ERR;
413   }
414
415   SUMMARIZE_ERR;
416#define RANK_wind 1
417   printf("**** testing simple variable renaming...");
418   {
419      /* This test contributed by Jeff Whitaker of NOAA - Thanks Jeff! */
420      int  ncidlat_dimtime_dimlon_dimwind_id;
421      size_t lat_len = 73, time_len = 10, lon_len = 145;
422      int cdf_goober[1];
423
424/*      if (nc_set_default_format(NC_FORMAT_NETCDF4, NULL)) ERR;*/
425      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
426
427      /* define dimensions */
428      if (nc_def_dim(ncid, "a", lon_len, &lon_dim)) ERR;
429      if (nc_def_dim(ncid, "b", lat_len, &lat_dim)) ERR;
430      if (nc_def_dim(ncid, "c", time_len, &time_dim)) ERR;
431
432      if (nc_put_att_text(ncidNC_GLOBAL, "a", 3, "bar")) ERR;
433      cdf_goober[0] = 2;
434      if (nc_put_att_int(ncidNC_GLOBAL, "b", NC_INT, 1, cdf_goober)) ERR;
435
436      /* define variables */
437      if (nc_def_var(ncid, "aa", NC_FLOATRANK_wind, &lon_dim, &wind_id)) ERR;
438      if (nc_close(ncid)) ERR;
439
440      if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
441      if (nc_rename_var(ncid, 0, "az")) ERR;
442      if (nc_close(ncid)) ERR;
443   }
444
445   SUMMARIZE_ERR;
446   printf("**** testing dimension and variable renaming...");
447   {
448      /* This test contributed by Jeff Whitaker of NOAA - Thanks Jeff! */
449      int  ncidlat_dimtime_dimlon_dimwind_id;
450      size_t lat_len = 73, time_len = 10, lon_len = 145;
451      int wind_dims[RANK_wind], wind_slobber[1], cdf_goober[1];
452
453      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
454
455      /* define dimensions */
456      if (nc_def_dim(ncid, "lon", lon_len, &lon_dim)) ERR;
457      if (nc_def_dim(ncid, "lat", lat_len, &lat_dim)) ERR;
458      if (nc_def_dim(ncid, "time", time_len, &time_dim)) ERR;
459
460      if (nc_put_att_text(ncidNC_GLOBAL, "foo", 3, "bar")) ERR;
461      cdf_goober[0] = 2;
462      if (nc_put_att_int(ncidNC_GLOBAL, "goober", NC_INT, 1, cdf_goober)) ERR;
463
464      /* define variables */
465      wind_dims[0] = lon_dim;
466      if (nc_def_var(ncid, "temp", NC_FLOATRANK_windwind_dims, &wind_id)) ERR;
467
468      if (nc_put_att_text(ncidwind_id, "bar", 3, "foo")) ERR;
469      wind_slobber[0] = 3;
470      if (nc_put_att_int(ncidwind_id, "slobber", NC_INT, 1, wind_slobber)) ERR;
471      if (nc_close(ncid)) ERR;
472
473      /* re-open dataset*/
474      if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
475      if (nc_inq_dimid(ncid, "lon", &lon_dim)) ERR;
476
477      /* rename dimension */
478      if (nc_rename_dim(ncidlon_dim, "longitude")) ERR;
479      if (nc_inq_varid(ncid, "temp", &wind_id)) ERR;
480
481      /* rename variable */
482      if (nc_rename_var(ncidwind_id, "wind")) ERR;
483      if (nc_close(ncid)) ERR;
484   }
485   SUMMARIZE_ERR;
486
487
488/*    printf("*** testing 2D array of NC_CHAR..."); */
489/*    { */
490/*       int dimid[NDIMS_1], var_dimids[VAR_DIMS] = {2, 0, 1}; */
491/*       float fill_value = -9999.0f; */
492/*       char long_name[] = PRES_MAX_WIND; */
493/*       int i, attid[NUM_ATTS]; */
494
495/*       ncid = nccreate(FILE_NAME, NC_NETCDF4); */
496
497/*       /\* Create dims. *\/ */
498/*       dimid[0] = ncdimdef(ncid, LAT, LAT_LEN); */
499/*       dimid[1] = ncdimdef(ncid, LON, LON_LEN); */
500
501/*       /\* Create var. *\/ */
502/*       varid = ncvardef(ncid, CXX_VAR_NAME, NC_FLOAT, VAR_DIMS, var_dimids); */
503/*       if (varid) ERR; */
504
505/*       ncclose(ncid); */
506
507/*       /\* Open the file and check. *\/ */
508/*       ncid = ncopen(FILE_NAME, 0); */
509/*       ncclose(ncid); */
510/*    } */
511
512/*    SUMMARIZE_ERR; */
513
514#define NDIMS 3
515#define NNAMES 4
516#define NLINES 13
517/*    printf("**** testing funny names for netCDF-4..."); */
518/*    { */
519/*       int  ncid, wind_id; */
520/*       size_t len[NDIMS] = {7, 3, 1}; */
521/*       int dimids[NDIMS], dimids_in[NDIMS], ndims_in; */
522/*       char funny_name[NNAMES][NC_MAX_NAME] = {"\a\t", "\f\n", "\r\v", "\b"}; */
523/*       char name_in[NC_MAX_NAME + 1]; */
524/*       char *speech[NLINES] = {"who would fardels bear, ", */
525/*        "To grunt and sweat under a weary life, ", */
526/*        "But that the dread of something after death, ", */
527/*        "The undiscover'd country from whose bourn ", */
528/*        "No traveller returns, puzzles the will ", */
529/*        "And makes us rather bear those ills we have ", */
530/*        "Than fly to others that we know not of? ", */
531/*        "Thus conscience does make cowards of us all; ", */
532/*        "And thus the native hue of resolution ", */
533/*        "Is sicklied o'er with the pale cast of thought, ", */
534/*        "And enterprises of great pith and moment ", */
535/*        "With this regard their currents turn awry, ", */
536/*        "And lose the name of action."}; */
537/*       char *speech_in[NLINES]; */
538/*       int i; */
539/*       unsigned short nlines = NLINES; */
540/*       unsigned int nlines_in; */
541
542/*       if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; */
543
544/*       /\* Define dimensions. *\/ */
545/*       for (i = 0; i < NDIMS; i++) */
546/*   if (nc_def_dim(ncid, funny_name[i], len[i], &dimids[i])) ERR; */
547
548/*       /\* Write some global atts. *\/ */
549/*       if (nc_put_att_string(ncid, NC_GLOBAL, funny_name[0], NLINES,  */
550/*      (const char **)speech)) ERR; */
551/*       if (nc_put_att_ushort(ncid, NC_GLOBAL, funny_name[1], NC_UINT, 1, &nlines)) ERR; */
552
553/*       /\* Define variables. *\/ */
554/*       if (nc_def_var(ncid, funny_name[3], NC_INT64, NDIMS, dimids, &wind_id)) ERR; */
555
556/*       if (nc_close(ncid)) ERR; */
557
558/*       /\* Open the file and check. *\/ */
559/*       if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; */
560/*       if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; */
561/*       if (ndims_in != NDIMS) ERR; */
562/*       for (i = 0; i < NDIMS; i++) */
563/*       { */
564/*   if (dimids_in[i] != i) ERR; */
565/*   if (nc_inq_dimname(ncid, i, name_in)) ERR; */
566/*   if (strcmp(name_in, funny_name[i])) ERR; */
567/*       } */
568
569/*       if (nc_get_att_string(ncid, NC_GLOBAL, funny_name[0], (char **)speech_in)) ERR; */
570/*       for (i = 0; i < NLINES; i++) */
571/*   if (strcmp(speech_in[i], speech[i])) ERR; */
572/*       if (nc_get_att_uint(ncid, NC_GLOBAL, funny_name[1], &nlines_in)) ERR; */
573/*       if (nlines_in != NLINES) ERR; */
574/*       if (nc_free_string(NLINES, (char **)speech_in)) ERR; */
575/*       if (nc_inq_varname(ncid, 0, name_in)) ERR; */
576/*       if (strcmp(name_in, funny_name[3])) ERR; */
577/*       if (nc_close(ncid)) ERR; */
578/*    } */
579/*    SUMMARIZE_ERR; */
580   printf("**** testing endianness...");
581
582#define NDIMS4 1
583#define DIM4_NAME "Joe"
584#define VAR_NAME4 "Ed"
585#define DIM4_LEN 10
586   {
587      int dimids[NDIMS4], dimids_in[NDIMS4];
588      int varid;
589      int ndimsnvarsnattsunlimdimid;
590      nc_type xtype_in;
591      char name_in[NC_MAX_NAME + 1];
592      int data[DIM4_LEN], data_in[DIM4_LEN];
593      int endian_in;
594      int i;
595
596      for (i = 0; i < DIM4_LENi++)
597         data[i] = i;
598
599      /* Create a netcdf-4 file with one dim and one var. */
600      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
601      if (nc_def_dim(ncidDIM4_NAMEDIM4_LEN, &dimids[0])) ERR;
602      if (dimids[0] != 0) ERR;
603      if (nc_def_var(ncidVAR_NAME4NC_INTNDIMS4dimids, &varid)) ERR;
604      if (nc_def_var_endian(ncidvaridNC_ENDIAN_BIG)) ERR;
605      if (varid != 0) ERR;
606      if (nc_put_var_int(ncidvariddata)) ERR;
607
608      /* Check stuff. */
609      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
610      if (ndims != NDIMS4 || nvars != 1 || natts != 0 ||
611          unlimdimid != -1) ERR;
612      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
613      if (nvars != 1) ERR;
614      if (varids_in[0] != 0) ERR;
615      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
616                     dimids_in, &natts)) ERR;
617      if (strcmp(name_inVAR_NAME4) || xtype_in != NC_INT ||
618          ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
619      if (nc_inq_var_endian(ncid, 0, &endian_in)) ERR;
620      if (endian_in != NC_ENDIAN_BIGERR;
621      if (nc_close(ncid)) ERR;
622
623      /* Open the file and check the same stuff. */
624      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
625
626      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
627      if (ndims != NDIMS4 || nvars != 1 || natts != 0 ||
628          unlimdimid != -1) ERR;
629      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
630      if (nvars != 1) ERR;
631      if (varids_in[0] != 0) ERR;
632      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
633                     dimids_in, &natts)) ERR;
634      if (strcmp(name_inVAR_NAME4) || xtype_in != NC_INT ||
635          ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
636      if (nc_inq_var_endian(ncid, 0, &endian_in)) ERR;
637      if (endian_in != NC_ENDIAN_BIGERR;
638      if (nc_get_var_int(ncidvariddata_in)) ERR;
639      for (i = 0; i < DIM4_LENi++)
640  if (data[i] != data_in[i]) ERR;
641
642      if (nc_close(ncid)) ERR;
643   }
644
645   SUMMARIZE_ERR;
646   printf("**** testing chunking and the chunk cache...");
647   {
648#define NDIMS5 1
649#define DIM5_NAME "D5"
650#define VAR_NAME5 "V5"
651#define DIM5_LEN 1000
652#define CACHE_SIZE 32000000
653#define CACHE_NELEMS 1009
654#define CACHE_PREEMPTION .75
655
656      int dimids[NDIMS5], dimids_in[NDIMS5];
657      int varid;
658      int ndimsnvarsnattsunlimdimid;
659      nc_type xtype_in;
660      char name_in[NC_MAX_NAME + 1];
661      int data[DIM5_LEN], data_in[DIM5_LEN];
662      size_t chunksize[NDIMS5] = {5};
663      size_t chunksize_in[NDIMS5];
664      int storage_in;
665      size_t cache_size_incache_nelems_in;
666      float cache_preemption_in;
667      int id;
668
669      for (i = 0; i < DIM5_LENi++)
670         data[i] = i;
671
672      /* Create a netcdf-4 file with one dim and one var. */
673      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
674      if (nc_def_dim(ncidDIM5_NAMEDIM5_LEN, &dimids[0])) ERR;
675      if (dimids[0] != 0) ERR;
676      if (nc_def_var(ncidVAR_NAME5NC_INTNDIMS5dimids, &varid)) ERR;
677      if (nc_def_var_chunking(ncidvaridNC_CHUNKEDchunksize)) ERR;
678      if (nc_set_var_chunk_cache(ncidvaridCACHE_SIZECACHE_NELEMSCACHE_PREEMPTION)) ERR;
679      if (nc_put_var_int(ncidvariddata)) ERR;
680
681      /* Check stuff. */
682      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
683      if (ndims != NDIMS5 || nvars != 1 || natts != 0 ||
684          unlimdimid != -1) ERR;
685      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
686      if (nvars != 1) ERR;
687      if (varids_in[0] != 0) ERR;
688      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
689      if (strcmp(name_inVAR_NAME5) || xtype_in != NC_INT || ndims != 1 || natts != 0 ||
690   dimids_in[0] != 0) ERR;
691      if (nc_inq_var_chunking(ncid, 0, &storage_inchunksize_in)) ERR;
692      for (d = 0; d < NDIMS5d++)
693  if (chunksize[d] != chunksize_in[d]) ERR;
694      if (storage_in != NC_CHUNKEDERR;
695      if (nc_get_var_int(ncidvariddata_in)) ERR;
696      for (i = 0; i < DIM5_LENi++)
697         if (data[i] != data_in[i])
698     ERR_RET;
699      if (nc_get_var_chunk_cache(ncidvarid, &cache_size_in, &cache_nelems_in,
700  &cache_preemption_in)) ERR;
701      if (cache_size_in != CACHE_SIZE || cache_nelems_in != CACHE_NELEMS ||
702   cache_preemption_in != CACHE_PREEMPTIONERR;
703      if (nc_close(ncid)) ERR;
704
705      /* Open the file and check the same stuff. */
706      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
707
708      /* Check stuff. */
709      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
710      if (ndims != NDIMS5 || nvars != 1 || natts != 0 ||
711          unlimdimid != -1) ERR;
712      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
713      if (nvars != 1) ERR;
714      if (varids_in[0] != 0) ERR;
715      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
716      if (strcmp(name_inVAR_NAME5) || xtype_in != NC_INT || ndims != 1 || natts != 0 ||
717   dimids_in[0] != 0) ERR;
718      if (nc_inq_var_chunking(ncid, 0, &storage_inchunksize_in)) ERR;
719      for (d = 0; d < NDIMS5d++)
720  if (chunksize[d] != chunksize_in[d]) ERR;
721      if (storage_in != NC_CHUNKEDERR;
722      if (nc_get_var_int(ncidvariddata_in)) ERR;
723      for (i = 0; i < DIM5_LENi++)
724         if (data[i] != data_in[i])
725     ERR_RET;
726      if (nc_close(ncid)) ERR;
727   }
728
729   SUMMARIZE_ERR;
730   printf("**** testing contiguous storage...");
731   {
732#define NDIMS6 1
733#define DIM6_NAME "D5"
734#define VAR_NAME6 "V5"
735#define DIM6_LEN 100
736
737      int dimids[NDIMS6], dimids_in[NDIMS6];
738      int varid;
739      int ndimsnvarsnattsunlimdimid;
740      nc_type xtype_in;
741      char name_in[NC_MAX_NAME + 1];
742      int data[DIM6_LEN], data_in[DIM6_LEN];
743      size_t chunksize_in[NDIMS6];
744      int storage_in;
745      int i;
746
747      for (i = 0; i < DIM6_LENi++)
748         data[i] = i;
749
750      /* Create a netcdf-4 file with one dim and one var. */
751      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
752      if (nc_def_dim(ncidDIM6_NAMEDIM6_LEN, &dimids[0])) ERR;
753      if (dimids[0] != 0) ERR;
754      if (nc_def_var(ncidVAR_NAME6NC_INTNDIMS6dimids, &varid)) ERR;
755      if (nc_def_var_chunking(ncidvaridNC_CONTIGUOUSNULL)) ERR;
756      if (nc_put_var_int(ncidvariddata)) ERR;
757
758      /* Check stuff. */
759      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
760      if (ndims != NDIMS6 || nvars != 1 || natts != 0 ||
761          unlimdimid != -1) ERR;
762      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
763      if (nvars != 1) ERR;
764      if (varids_in[0] != 0) ERR;
765      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
766      if (strcmp(name_inVAR_NAME6) || xtype_in != NC_INT || ndims != 1 || natts != 0 ||
767   dimids_in[0] != 0) ERR;
768      if (nc_inq_var_chunking(ncid, 0, &storage_inchunksize_in)) ERR;
769      if (storage_in != NC_CONTIGUOUSERR;
770      if (nc_get_var_int(ncidvariddata_in)) ERR;
771      for (i = 0; i < DIM6_LENi++)
772         if (data_in[i] != data[i])
773     ERR_RET;
774      if (nc_close(ncid)) ERR;
775
776      /* Open the file and check the same stuff. */
777      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
778
779      /* Check stuff. */
780      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
781      if (ndims != NDIMS6 || nvars != 1 || natts != 0 ||
782          unlimdimid != -1) ERR;
783      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
784      if (nvars != 1) ERR;
785      if (varids_in[0] != 0) ERR;
786      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
787      if (strcmp(name_inVAR_NAME6) || xtype_in != NC_INT || ndims != 1 || natts != 0 ||
788   dimids_in[0] != 0) ERR;
789      if (nc_inq_var_chunking(ncid, 0, &storage_inchunksize_in)) ERR;
790      if (storage_in != NC_CONTIGUOUSERR;
791      if (nc_get_var_int(ncidvariddata_in)) ERR;
792      for (i = 0; i < DIM6_LENi++)
793         if (data[i] != data_in[i])
794     ERR_RET;
795      if (nc_close(ncid)) ERR;
796   }
797
798   SUMMARIZE_ERR;
799   printf("**** testing extreme numbers dude...");
800   {
801#define VAR_NAME7 "V5"
802#define DIM6_LEN 100
803
804      int varid;
805      int ndimsnvarsnattsunlimdimid;
806      nc_type xtype_in;
807      char name_in[NC_MAX_NAME + 1];
808/*      unsigned long long data = 9223372036854775807ull, data_in;*/
809      unsigned long long data = 9223372036854775817ulldata_in;
810
811      /* Create a netcdf-4 file with scalar var. */
812      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
813      if (nc_def_var(ncidVAR_NAME7NC_UINT64, 0, NULL, &varid)) ERR;
814      if (nc_put_var_ulonglong(ncidvarid, &data)) ERR;
815
816      /* Check stuff. */
817      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
818      if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
819      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
820      if (nvars != 1 || varids_in[0] != 0) ERR;
821      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsNULL, &natts)) ERR;
822      if (strcmp(name_inVAR_NAME7) || xtype_in != NC_UINT64 || ndims != 0 || natts != 0) ERR;
823      if (nc_get_var_ulonglong(ncidvarid, &data_in)) ERR;
824      if (data_in != dataERR;
825      if (nc_close(ncid)) ERR;
826
827      /* Open the file and check the same stuff. */
828      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
829      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
830      if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
831      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
832      if (nvars != 1 || varids_in[0] != 0) ERR;
833      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsNULL, &natts)) ERR;
834      if (strcmp(name_inVAR_NAME7) || xtype_in != NC_UINT64 || ndims != 0 || natts != 0) ERR;
835      if (nc_get_var_ulonglong(ncidvarid, &data_in)) ERR;
836      if (data_in != dataERR;
837      if (nc_close(ncid)) ERR;
838   }
839
840   SUMMARIZE_ERR;
841   printf("**** testing error codes for name clashes...");
842   {
843#define GENERIC_NAME "bob"
844      int ncidvaridnumgrpsntypes;
845
846      /* Create a netcdf-4 file with one var. */
847      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
848      if (nc_def_var(ncidGENERIC_NAMENC_BYTE, 0, NULL, &varid)) ERR;
849
850      /* These don'e work, because the name is already in use. Make
851       * sure the correct error is returned. */
852      if (nc_def_grp(ncidGENERIC_NAMENULL) != NC_ENAMEINUSEERR;
853      if (nc_def_opaque(ncid, 1, GENERIC_NAMENULL) != NC_ENAMEINUSEERR;
854
855      /* Close it. */
856      if (nc_close(ncid)) ERR;
857
858      /* Open the file and check. */
859      if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
860      if (nc_inq_varids(ncid, &nvars_invarids_in)) ERR;
861      if (nvars_in != 1 || varids_in[0] != 0) ERR;
862      if (nc_inq_varname(ncid, 0, name_in)) ERR;
863      if (strcmp(name_inGENERIC_NAME)) ERR;
864      if (nc_inq_grps(ncid, &numgrpsNULL)) ERR;
865      if (numgrpsERR;
866      if (nc_inq_typeids(ncid, &ntypesNULL)) ERR;
867      if (ntypesERR;
868      if (nc_close(ncid)) ERR;
869   }
870
871   SUMMARIZE_ERR;
872   printf("**** testing error codes for name clashes some more...");
873
874   {
875#define GENERIC_NAME "bob"
876      int ncidvaridnumgrpsntypes;
877
878      /* Create a netcdf-4 file with one type. */
879      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
880      if (nc_def_opaque(ncid, 1, GENERIC_NAMENULL)) ERR;
881
882      /* These don'e work, because the name is already in use. Make
883       * sure the correct error is returned. */
884      if (nc_def_grp(ncidGENERIC_NAMENULL) != NC_ENAMEINUSEERR;
885      if (nc_def_var(ncidGENERIC_NAMENC_BYTE, 0, NULL, &varid) != NC_ENAMEINUSEERR;
886
887      /* Close it. */
888      if (nc_close(ncid)) ERR;
889
890      /* Open the file and check. */
891      if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
892      if (nc_inq_varids(ncid, &nvars_invarids_in)) ERR;
893      if (nvars_inERR;
894      if (nc_inq_grps(ncid, &numgrpsNULL)) ERR;
895      if (numgrpsERR;
896      if (nc_inq_typeids(ncid, &ntypesNULL)) ERR;
897      if (ntypes != 1) ERR;
898      if (nc_close(ncid)) ERR;
899   }
900   SUMMARIZE_ERR;
901   printf("**** testing error codes for name clashes even more...");
902
903   {
904#define GENERIC_NAME "bob"
905      int ncidvaridnumgrpsntypes;
906
907      /* Create a netcdf-4 file with one group. */
908      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
909      if (nc_def_grp(ncidGENERIC_NAMENULL)) ERR;
910
911      /* These don'e work, because the name is already in use. Make
912       * sure the correct error is returned. */
913      if (nc_def_opaque(ncid, 1, GENERIC_NAMENULL) != NC_ENAMEINUSEERR;
914      if (nc_def_var(ncidGENERIC_NAMENC_BYTE, 0, NULL, &varid) != NC_ENAMEINUSEERR;
915
916      /* Close it. */
917      if (nc_close(ncid)) ERR;
918
919      /* Open the file and check. */
920      if (nc_open(FILE_NAMENC_WRITE, &ncid)) ERR;
921      if (nc_inq_varids(ncid, &nvars_invarids_in)) ERR;
922      if (nvars_inERR;
923      if (nc_inq_grps(ncid, &numgrpsNULL)) ERR;
924      if (numgrps != 1) ERR;
925      if (nc_inq_typeids(ncid, &ntypesNULL)) ERR;
926      if (ntypesERR;
927      if (nc_close(ncid)) ERR;
928   }
929   SUMMARIZE_ERR;
930   printf("**** testing error code for too-large chunks...");
931   {
932#define NDIMS17 2
933#define DIM17_NAME "personality"
934#define DIM17_NAME_2 "good_looks"
935#define VAR_NAME17 "ed"
936#define DIM17_LEN 2147483644 /* max dimension size - 2GB - 4. */
937#define DIM17_2_LEN 1000
938
939      int dimids[NDIMS17], dimids_in[NDIMS17];
940      int varid;
941      int ndimsnvarsnattsunlimdimid;
942      nc_type xtype_in;
943      char name_in[NC_MAX_NAME + 1];
944      size_t chunksize[NDIMS17] = {5, 5};
945      size_t bad_chunksize[NDIMS17] = {5, DIM17_LEN};
946      size_t chunksize_in[NDIMS17];
947      int storage_in;
948      int d;
949
950      /* Create a netcdf-4 file with two dims and one var. */
951      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
952      if (nc_def_dim(ncidDIM17_NAMEDIM17_LEN, &dimids[0])) ERR;
953      if (nc_def_dim(ncidDIM17_NAME_2DIM17_2_LEN, &dimids[1])) ERR;
954      if (dimids[0] != 0 || dimids[1] != 1) ERR;
955      if (nc_def_var(ncidVAR_NAME17NC_UINT64NDIMS17dimids, &varid)) ERR;
956      if (nc_def_var_chunking(ncidvaridNC_CHUNKEDbad_chunksize) != NC_EBADCHUNKERR;
957      if (nc_def_var_chunking(ncidvaridNC_CHUNKEDchunksize)) ERR;
958
959      /* Check stuff. */
960      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
961      if (ndims != NDIMS17 || nvars != 1 || natts != 0 ||
962          unlimdimid != -1) ERR;
963      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
964      if (nvars != 1) ERR;
965      if (varids_in[0] != 0) ERR;
966      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
967      if (strcmp(name_inVAR_NAME17) || xtype_in != NC_UINT64 || ndims != 2 || natts != 0 ||
968   dimids_in[0] != 0 || dimids_in[1] != 1) ERR;
969      if (nc_inq_var_chunking(ncid, 0, &storage_inchunksize_in)) ERR;
970      for (d = 0; d < NDIMS17d++)
971  if (chunksize[d] != chunksize_in[d]) ERR;
972      if (storage_in != NC_CHUNKEDERR;
973      if (nc_close(ncid)) ERR;
974
975      /* Open the file and check the same stuff. */
976      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
977
978      /* Check stuff. */
979      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
980      if (ndims != NDIMS17 || nvars != 1 || natts != 0 ||
981          unlimdimid != -1) ERR;
982      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
983      if (nvars != 1) ERR;
984      if (varids_in[0] != 0) ERR;
985      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
986      if (strcmp(name_inVAR_NAME17) || xtype_in != NC_UINT64 || ndims != 2 || natts != 0 ||
987   dimids_in[0] != 0 || dimids_in[1] != 1) ERR;
988      if (nc_inq_var_chunking(ncid, 0, &storage_inchunksize_in)) ERR;
989      for (d = 0; d < NDIMS17d++)
990  if (chunksize[d] != chunksize_in[d]) ERR;
991      if (storage_in != NC_CHUNKEDERR;
992      if (nc_close(ncid)) ERR;
993   }
994   SUMMARIZE_ERR;
995#define NDIMS6 1
996#define DIM8_NAME "num_monkeys"
997#define DIM9_NAME "num_coconuts"
998#define DIM9_LEN 10
999#define VAR_NAME8 "John_Clayton"
1000#define VAR_NAME9 "Lord_Greystoke"
1001   printf("**** testing that contiguous storage can't be turned on for vars with unlimited dims or filters...");
1002   {
1003      int ncid;
1004      int dimids[NDIMS6];
1005      int varidvarid2;
1006      size_t chunksize_in[NDIMS6];
1007      int storage_in;
1008
1009      /* Create a netcdf-4 file with one dim and some vars. */
1010      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
1011      if (nc_def_dim(ncidDIM8_NAMENC_UNLIMITED, &dimids[0])) ERR;
1012      if (nc_def_var(ncidVAR_NAME8NC_INTNDIMS6dimids, &varid)) ERR;
1013      if (nc_def_dim(ncidDIM9_NAMEDIM9_LEN, &dimids[0])) ERR;
1014      if (nc_def_var(ncidVAR_NAME9NC_INTNDIMS6dimids, &varid2)) ERR;
1015      if (nc_def_var_deflate(ncidvarid2, 0, 1, 4)) ERR;
1016
1017      /* This won't work because of the umlimited dimension. */
1018      if (nc_def_var_chunking(ncidvaridNC_CONTIGUOUSNULL) != NC_EINVALERR;
1019
1020      /* This won't work because of the deflate filter. */
1021      if (nc_def_var_chunking(ncidvarid2NC_CONTIGUOUSNULL) != NC_EINVALERR;
1022
1023      /* Storage must be chunked because of unlimited dimension and
1024       * the deflate filter. */
1025      if (nc_inq_var_chunking(ncidvarid, &storage_inchunksize_in)) ERR;
1026      if (storage_in != NC_CHUNKEDERR;
1027      if (nc_inq_var_chunking(ncidvarid2, &storage_inchunksize_in)) ERR;
1028      if (storage_in != NC_CHUNKEDERR;
1029      if (nc_close(ncid)) ERR;
1030
1031   }
1032   SUMMARIZE_ERR;
1033#define NDIMS6 1
1034#define DIM8_NAME "num_monkeys"
1035#define DIM9_NAME "num_coconuts"
1036#define DIM9_LEN 10
1037#define VAR_NAME8 "John_Clayton"
1038#define VAR_NAME9 "Lord_Greystoke"
1039   printf("**** testing that contiguous storage can't be turned on for vars with unlimited dims or filters...");
1040   {
1041      int ncid;
1042      int dimids[NDIMS6];
1043      int varidvarid2;
1044      size_t chunksize_in[NDIMS6];
1045      int storage_in;
1046
1047      /* Create a netcdf-4 file with one dim and some vars. */
1048      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
1049      if (nc_def_dim(ncidDIM8_NAMENC_UNLIMITED, &dimids[0])) ERR;
1050      if (nc_def_var(ncidVAR_NAME8NC_INTNDIMS6dimids, &varid)) ERR;
1051      if (nc_def_dim(ncidDIM9_NAMEDIM9_LEN, &dimids[0])) ERR;
1052      if (nc_def_var(ncidVAR_NAME9NC_INTNDIMS6dimids, &varid2)) ERR;
1053      if (nc_def_var_deflate(ncidvarid2, 0, 1, 4)) ERR;
1054
1055      /* This won't work because of the umlimited dimension. */
1056      if (nc_def_var_chunking(ncidvaridNC_CONTIGUOUSNULL) != NC_EINVALERR;
1057
1058      /* This won't work because of the deflate filter. */
1059      if (nc_def_var_chunking(ncidvarid2NC_CONTIGUOUSNULL) != NC_EINVALERR;
1060
1061      /* Storage must be chunked because of unlimited dimension and
1062       * the deflate filter. */
1063      if (nc_inq_var_chunking(ncidvarid, &storage_inchunksize_in)) ERR;
1064      if (storage_in != NC_CHUNKEDERR;
1065      if (nc_inq_var_chunking(ncidvarid2, &storage_inchunksize_in)) ERR;
1066      if (storage_in != NC_CHUNKEDERR;
1067      if (nc_close(ncid)) ERR;
1068
1069   }
1070   SUMMARIZE_ERR;
1071   FINAL_RESULTS;
1072}


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