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_vars.c,v 1.49 2009/12/30 12:03:48 ed Exp $
7*/
8
9#include <nc_tests.h>
10#include "err_macros.h"
11#include "netcdf.h"
12
13#define FILE_NAME "tst_vars.nc"
14#define VAR_BYTE_NAME "Portrait_of_Maria_Trip"
15#define VAR_CHAR_NAME "Landscape_wth_stone_bridge"
16#define VAR_SHORT_NAME "Self-portrait_as_a_young_man"
17#define VAR_INT_NAME "Jeremiah_lamenting_the_destruction_of_Jerusalem"
18#define VAR_FLOAT_NAME "The_Syndics_of_the_Drapers_Guild"
19#define VAR_DOUBLE_NAME "Self-portrait_as_the_apstle_Paul"
20#define VAR_UBYTE_NAME "Tobias_and_Anna_with_the_kid"
21#define VAR_USHORT_NAME "The_Jewish_Bride"
22#define VAR_UINT_NAME "The_prophetess_Anna"
23#define VAR_INT64_NAME "Titus_as_a_Monk"
24#define VAR_UINT64_NAME "The_Night_Watch"
25#define DIM1_NAME "x"
26#define DIM1_LEN 2
27#define DIM2_NAME "y"
28#define DIM2_LEN 3
29#define DIM3_NAME "strlen"
30#define DIM3_LEN 25
31#define NC_ERR 2
32
33/* From here down, the defines are for the creation of the
34   pres_temp_4D example file, which is also created under examples,
35   but here is created in all file formats, and more extensively
36   tested for correctness. We are writing 4D data, a 2 x 6 x 12
37   lvl-lat-lon grid, with 2 timesteps of data. */
38#define NDIMS_EX 4
39#define NLAT 6
40#define NLON 12
41#define LAT_NAME "latitude"
42#define LON_NAME "longitude"
43#define NREC 2
44#define REC_NAME "time"
45#define LVL_NAME "level"
46#define NLVL 2
47
48/* Names of things. */
49#define PRES_NAME "pressure"
50#define TEMP_NAME "temperature"
51#define UNITS "units"
52#define DEGREES_EAST "degrees_east"
53#define DEGREES_NORTH "degrees_north"
54
55/* There are 4 vars, two for data, two for coordinate data. */
56#define NVARS_EX 4
57
58/* These are used to construct some example data. */
59#define SAMPLE_PRESSURE 900
60#define SAMPLE_TEMP 9.0
61#define START_LAT 25.0
62#define START_LON -125.0
63
64/* For the units attributes. */
65#define UNITS "units"
66#define PRES_UNITS "hPa"
67#define TEMP_UNITS "celsius"
68#define LAT_UNITS "degrees_north"
69#define LON_UNITS "degrees_east"
70#define MAX_ATT_LEN 80
71
72int
73create_4D_example(char *file_name, int cmode)
74{
75   /* IDs for the netCDF file, dimensions, and variables. */
76   int ncidlon_dimidlat_dimidlvl_dimidrec_dimid;
77   int lat_varidlon_varidpres_varidtemp_varid;
78   int dimids[NDIMS_EX];
79
80   /* The start and count arrays will tell the netCDF library where to
81      write our data. */
82   size_t start[NDIMS_EX], count[NDIMS_EX];
83
84   /* Program variables to hold the data we will write out. We will only
85      need enough space to hold one timestep of data; one record. */
86   float pres_out[NLVL][NLAT][NLON];
87   float temp_out[NLVL][NLAT][NLON];
88
89   /* These program variables hold the latitudes and longitudes. */
90   float lats[NLAT], lons[NLON];
91
92   /* Loop indexes. */
93   int lvllatlonreci = 0;
94
95   /* Create some pretend data. If this wasn't an example program, we
96    * would have some real data to write, for example, model
97    * output. */
98   for (lat = 0; lat < NLATlat++)
99      lats[lat] = START_LAT + 5.*lat;
100   for (lon = 0; lon < NLONlon++)
101      lons[lon] = START_LON + 5.*lon;
102
103   for (lvl = 0; lvl < NLVLlvl++)
104      for (lat = 0; lat < NLATlat++)
105  for (lon = 0; lon < NLONlon++)
106  {
107     pres_out[lvl][lat][lon] = SAMPLE_PRESSURE + i;
108     temp_out[lvl][lat][lon] = SAMPLE_TEMP + i++;
109  }
110
111   /* Create the file. */
112   if (nc_create(file_namecmode, &ncid)) ERR;
113
114   /* Define the dimensions. The record dimension is defined to have
115    * unlimited length - it can grow as needed. In this example it is
116    * the time dimension.*/
117   if (nc_def_dim(ncidLVL_NAMENLVL, &lvl_dimid)) ERR;
118   if (nc_def_dim(ncidLAT_NAMENLAT, &lat_dimid)) ERR;
119   if (nc_def_dim(ncidLON_NAMENLON, &lon_dimid)) ERR;
120   if (nc_def_dim(ncidREC_NAMENC_UNLIMITED, &rec_dimid)) ERR;
121
122   /* Define the coordinate variables. We will only define coordinate
123      variables for lat and lon.  Ordinarily we would need to provide
124      an array of dimension IDs for each variable's dimensions, but
125      since coordinate variables only have one dimension, we can
126      simply provide the address of that dimension ID (&lat_dimid) and
127      similarly for (&lon_dimid). */
128   if (nc_def_var(ncidLAT_NAMENC_FLOAT, 1, &lat_dimid,
129     &lat_varid)) ERR;
130   if (nc_def_var(ncidLON_NAMENC_FLOAT, 1, &lon_dimid,
131     &lon_varid)) ERR;
132
133   /* Assign units attributes to coordinate variables. */
134   if (nc_put_att_text(ncidlat_varidUNITS,
135  strlen(DEGREES_NORTH), DEGREES_NORTH)) ERR;
136   if (nc_put_att_text(ncidlon_varidUNITS,
137  strlen(DEGREES_EAST), DEGREES_EAST)) ERR;
138
139   /* The dimids array is used to pass the dimids of the dimensions of
140      the netCDF variables. Both of the netCDF variables we are
141      creating share the same four dimensions. In C, the
142      unlimited dimension must come first on the list of dimids. */
143   dimids[0] = rec_dimid;
144   dimids[1] = lvl_dimid;
145   dimids[2] = lat_dimid;
146   dimids[3] = lon_dimid;
147
148   /* Define the netCDF variables for the pressure and temperature
149    * data. */
150   if (nc_def_var(ncidPRES_NAMENC_FLOATNDIMS_EX,
151     dimids, &pres_varid)) ERR;
152   if (nc_def_var(ncidTEMP_NAMENC_FLOATNDIMS_EX,
153     dimids, &temp_varid)) ERR;
154
155   /* Assign units attributes to the netCDF variables. */
156   if (nc_put_att_text(ncidpres_varidUNITS,
157  strlen(PRES_UNITS), PRES_UNITS)) ERR;
158   if (nc_put_att_text(ncidtemp_varidUNITS,
159  strlen(TEMP_UNITS), TEMP_UNITS)) ERR;
160
161   /* End define mode. */
162   if (nc_enddef(ncid)) ERR;
163
164   /* Write the coordinate variable data. This will put the latitudes
165      and longitudes of our data grid into the netCDF file. */
166   if (nc_put_var_float(ncidlat_varid, &lats[0])) ERR;
167   if (nc_put_var_float(ncidlon_varid, &lons[0])) ERR;
168
169   /* These settings tell netcdf to write one timestep of data. (The
170      setting of start[0] inside the loop below tells netCDF which
171      timestep to write.) */
172   count[0] = 1;
173   count[1] = NLVL;
174   count[2] = NLAT;
175   count[3] = NLON;
176   start[1] = 0;
177   start[2] = 0;
178   start[3] = 0;
179
180   /* Write the pretend data. This will write our surface pressure and
181      surface temperature data. The arrays only hold one timestep worth
182      of data. We will just rewrite the same data for each timestep. In
183      a real application, the data would change between timesteps. */
184   for (rec = 0; rec < NRECrec++)
185   {
186      start[0] = rec;
187      if (nc_put_vara_float(ncidpres_varidstartcount,
188       &pres_out[0][0][0])) ERR;
189      if (nc_put_vara_float(ncidtemp_varidstartcount,
190       &temp_out[0][0][0])) ERR;
191   }
192
193   /* Close the file. */
194   if (nc_close(ncid)) ERR;
195
196   return err;
197}
198
199int
200check_4D_example(char *file_name, int expected_format)
201{
202   int ncid;
203   int formatndims_innvars_innatts_in;
204   int dimid[NDIMS_EX];
205   int varid[NVARS_EX];
206   char dim_name_in[NDIMS_EX][NC_MAX_NAME];
207   char var_name_in[NVARS_EX][NC_MAX_NAME];
208   char name_in[NC_MAX_NAME + 1];
209   char units_in[NC_MAX_NAME + 1];
210   nc_type xtype_in;
211   size_t len_in;
212   int i;
213
214   if (nc_open(file_name, 0, &ncid)) ERR;
215
216   /* Count stuff. */
217   if (nc_inq_format(ncid, &format)) ERR;
218   if (nc_inq_ndims(ncid, &ndims_in)) ERR;
219   if (ndims_in != NDIMS_EXERR;
220   if (nc_inq_nvars(ncid, &nvars_in)) ERR;
221   if (nvars_in != NVARS_EXERR;
222   if (nc_inq_natts(ncid, &natts_in)) ERR;
223   if (natts_in != 0) ERR;
224   if (format != expected_formatERR;
225
226   /* Check dimensions. */
227   ndims_in = 0;
228   if (nc_inq_dimids(ncid, &ndims_indimid, 0)) ERR;
229   if (ndims_in != NDIMS_EXERR;
230   for (i = 0; i < NDIMS_EXi++)
231   {
232      if (dimid[i] != iERR;
233      if (nc_inq_dimname(ncididim_name_in[i])) ERR;
234   }
235   if (strcmp(dim_name_in[0], LVL_NAME) || strcmp(dim_name_in[1], LAT_NAME) ||
236       strcmp(dim_name_in[2], LON_NAME) || strcmp(dim_name_in[3], REC_NAME)) ERR;
237
238   /* Check variables. */
239   nvars_in = 0;
240   if (nc_inq_varids(ncid, &nvars_invarid)) ERR;
241   if (nvars_in != NVARS_EXERR;
242   for (i = 0; i < NVARS_EXi++)
243   {
244      if (varid[i] != iERR;
245      if (nc_inq_varname(ncidivar_name_in[i])) ERR;
246   }
247   if (strcmp(var_name_in[0], LAT_NAME) || strcmp(var_name_in[1], LON_NAME) ||
248       strcmp(var_name_in[2], PRES_NAME) || strcmp(var_name_in[3], TEMP_NAME)) ERR;
249
250   if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_indimid, &natts_in)) ERR;
251   if (strcmp(name_inLAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
252       dimid[0] != 1 || natts_in != 1) ERR;
253   if (nc_inq_var(ncid, 1, name_in, &xtype_in, &ndims_indimid, &natts_in)) ERR;
254   if (strcmp(name_inLON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
255       dimid[0] != 2 || natts_in != 1) ERR;
256   if (nc_inq_var(ncid, 2, name_in, &xtype_in, &ndims_indimid, &natts_in)) ERR;
257   if (strcmp(name_inPRES_NAME) || xtype_in != NC_FLOAT || ndims_in != 4 ||
258       dimid[0] != 3 || dimid[1] != 0 || dimid[2] != 1 || dimid[3] != 2 ||
259       natts_in != 1) ERR;
260   if (nc_inq_var(ncid, 3, name_in, &xtype_in, &ndims_indimid, &natts_in)) ERR;
261   if (strcmp(name_inTEMP_NAME) || xtype_in != NC_FLOAT || ndims_in != 4 ||
262       dimid[0] != 3 || dimid[1] != 0 || dimid[2] != 1 || dimid[3] != 2 ||
263       natts_in != 1) ERR;
264
265   /* Check variable atts. */
266   if (nc_inq_att(ncid, 0, UNITS, &xtype_in, &len_in)) ERR;
267   if (xtype_in != NC_CHAR || len_in != strlen(DEGREES_NORTH)) ERR;
268   if (nc_get_att_text(ncid, 0, UNITSunits_in)) ERR;
269   if (strncmp(units_inDEGREES_NORTH, strlen(DEGREES_NORTH))) ERR;
270
271   if (nc_inq_att(ncid, 1, UNITS, &xtype_in, &len_in)) ERR;
272   if (xtype_in != NC_CHAR || len_in != strlen(DEGREES_EAST)) ERR;
273   if (nc_get_att_text(ncid, 1, UNITSunits_in)) ERR;
274   if (strncmp(units_inDEGREES_EAST, strlen(DEGREES_EAST))) ERR;
275
276   if (nc_inq_att(ncid, 2, UNITS, &xtype_in, &len_in)) ERR;
277   if (xtype_in != NC_CHAR || len_in != strlen(PRES_UNITS)) ERR;
278   if (nc_get_att_text(ncid, 2, UNITSunits_in)) ERR;
279   if (strncmp(units_inPRES_UNITS, strlen(PRES_UNITS))) ERR;
280
281   if (nc_inq_att(ncid, 3, UNITS, &xtype_in, &len_in)) ERR;
282   if (xtype_in != NC_CHAR || len_in != strlen(TEMP_UNITS)) ERR;
283   if (nc_get_att_text(ncid, 3, UNITSunits_in)) ERR;
284   if (strncmp(units_inTEMP_UNITS, strlen(TEMP_UNITS))) ERR;
285
286   if (nc_close(ncid)) ERR;
287   return err;
288}
289
290int
291main(int argc, char **argv)
292{
293   int nciddimids[3];
294   int char_varidbyte_varidubyte_varidshort_varidint_varidfloat_variddouble_varid;
295   int ushort_variduint_varidint64_variduint64_varid;
296   int ij;
297
298   unsigned char ubyte_out[DIM1_LEN][DIM2_LEN] = {{1, 128, 255},{1, 128, 255}};
299   signed char byte_in[DIM1_LEN][DIM2_LEN], byte_out[DIM1_LEN][DIM2_LEN] = {{-127, 1, 127},{-127, 1, 127}};
300   unsigned short ushort_out[DIM1_LEN][DIM2_LEN] = {{110, 128, 255},{110, 128, 255}};
301   short short_in[DIM1_LEN][DIM2_LEN], short_out[DIM1_LEN][DIM2_LEN] = {{-110, -128, 255},{-110, -128, 255}};
302   int int_in[DIM1_LEN][DIM2_LEN], int_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
303   float float_in[DIM1_LEN][DIM2_LEN], float_out[DIM1_LEN][DIM2_LEN] = {{-.1, 9999.99, 100.001},{-.1, 9999.99, 100.001}};
304   double double_in[DIM1_LEN][DIM2_LEN], double_out[DIM1_LEN][DIM2_LEN] = {{0.02, .1128, 1090.1},{0.02, .1128, 1090.1}};
305   unsigned int uint_in[DIM1_LEN][DIM2_LEN], uint_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
306   long long int64_in[DIM1_LEN][DIM2_LEN], int64_out[DIM1_LEN][DIM2_LEN] = {{-111, 777, 100},{-111, 777, 100}};
307   unsigned long long uint64_in[DIM1_LEN][DIM2_LEN];
308   unsigned long long uint64_out[DIM1_LEN][DIM2_LEN] = {{0, 10101, 9999999},{0, 10101, 9999999}};
309   char char_out[DIM1_LEN][DIM2_LEN][DIM3_LEN] = {{"lalala", "lololo", "lelele"}, {"lalala", "lololo", "lelele"}};
310
311   printf("\n*** Testing netcdf-4 variable functions.\n");
312
313   printf("*** testing netcdf-4 varids inq on netcdf-3 file...");
314   {
315      int nvars_invarids_in[2];
316
317      /* Create a netcdf-3 file with one dim and two vars. */
318      if (nc_create(FILE_NAME, 0, &ncid)) ERR;
319      if (nc_def_dim(ncidDIM1_NAMEDIM1_LEN, &dimids[0])) ERR;
320      if (nc_def_dim(ncidDIM2_NAMEDIM2_LEN, &dimids[1])) ERR;
321      if (nc_def_dim(ncidDIM3_NAMEDIM3_LEN, &dimids[2])) ERR;
322      if (nc_def_var(ncidVAR_BYTE_NAMENC_BYTE, 2, dimids, &byte_varid)) ERR;
323      if (nc_def_var(ncidVAR_CHAR_NAMENC_CHAR, 3, dimids, &char_varid)) ERR;
324      if (nc_close(ncid)) ERR;
325
326      /* Open the file and make sure nc_inq_varids yeilds correct
327       * result. */
328      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
329      if (nc_inq_varids(ncid, &nvars_invarids_in)) ERR;
330      if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR;
331      if (nc_close(ncid)) ERR;
332   }
333
334   SUMMARIZE_ERR;
335   printf("*** testing simple variables...");
336
337   {
338      /* Create a file with a variable of each type. */
339      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
340      if (nc_def_dim(ncidDIM1_NAMEDIM1_LEN, &dimids[0])) ERR;
341      if (nc_def_dim(ncidDIM2_NAMEDIM2_LEN, &dimids[1])) ERR;
342      if (nc_def_dim(ncidDIM3_NAMEDIM3_LEN, &dimids[2])) ERR;
343      if (nc_def_var(ncidVAR_BYTE_NAMENC_BYTE, 2, dimids, &byte_varid)) ERR;
344      if (nc_def_var(ncidVAR_CHAR_NAMENC_CHAR, 3, dimids, &char_varid)) ERR;
345      if (nc_def_var(ncidVAR_SHORT_NAMENC_SHORT, 2, dimids, &short_varid)) ERR;
346      if (nc_def_var(ncidVAR_INT_NAMENC_INT, 2, dimids, &int_varid)) ERR;
347      if (nc_def_var(ncidVAR_FLOAT_NAMENC_FLOAT, 2, dimids, &float_varid)) ERR;
348      if (nc_def_var(ncidVAR_DOUBLE_NAMENC_DOUBLE, 2, dimids, &double_varid)) ERR;
349      if (nc_def_var(ncidVAR_UBYTE_NAMENC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
350      if (nc_def_var(ncidVAR_USHORT_NAMENC_USHORT, 2, dimids, &ushort_varid)) ERR;
351      if (nc_def_var(ncidVAR_UINT_NAMENC_UINT, 2, dimids, &uint_varid)) ERR;
352      if (nc_def_var(ncidVAR_INT64_NAMENC_INT64, 2, dimids, &int64_varid)) ERR;
353      if (nc_def_var(ncidVAR_UINT64_NAMENC_UINT64, 2, dimids, &uint64_varid)) ERR;
354      if (nc_put_var_schar(ncidbyte_varid, (signed char *)byte_out)) ERR;
355      if (nc_put_var_text(ncidchar_varid, (char *)char_out)) ERR;
356      if (nc_put_var_short(ncidshort_varid, (short *)short_out)) ERR;
357      if (nc_put_var_int(ncidint_varid, (int *)int_out)) ERR;
358      if (nc_put_var_float(ncidfloat_varid, (float *)float_out)) ERR;
359      if (nc_put_var_double(nciddouble_varid, (double *)double_out)) ERR;
360      if (nc_put_var_uchar(ncidubyte_varid, (unsigned char *)ubyte_out)) ERR;
361      if (nc_put_var_ushort(ncidushort_varid, (unsigned short *)ushort_out)) ERR;
362      if (nc_put_var_uint(nciduint_varid, (unsigned int *)uint_out)) ERR;
363      if (nc_put_var_longlong(ncidint64_varid, (long long *)int64_out)) ERR;
364      if (nc_put_var_ulonglong(nciduint64_varid, (unsigned long long *)uint64_out)) ERR;
365      if (nc_close(ncid)) ERR;
366
367      /* Open the file and check metadata. */
368      {
369  nc_type xtype_in;
370  int ndims_indimids_in[10], natts_invarid_in;
371  char name_in[NC_MAX_NAME+1];
372  size_t size_in;
373
374  if (nc_open(FILE_NAME, 0, &ncid)) ERR;
375  if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_indimids_in,
376 &natts_in)) ERR;
377  if (strcmp(name_inVAR_BYTE_NAME) || xtype_in != NC_BYTE ||
378      ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
379      dimids_in[1] != dimids[1]) ERR;
380  if (nc_inq_varid(ncidVAR_BYTE_NAME, &varid_in)) ERR;
381  if (varid_in != 0) ERR;
382  if (nc_inq_varid(ncidVAR_CHAR_NAME, &varid_in)) ERR;
383  if (varid_in != 1) ERR;
384  if (nc_inq_varid(ncidVAR_SHORT_NAME, &varid_in)) ERR;
385  if (varid_in != 2) ERR;
386  if (nc_inq_varname(ncid, 0, name_in)) ERR;
387  if (strcmp(name_inVAR_BYTE_NAME)) ERR;
388  if (nc_inq_varname(ncid, 1, name_in)) ERR;
389  if (strcmp(name_inVAR_CHAR_NAME)) ERR;
390  if (nc_inq_varname(ncid, 2, name_in)) ERR;
391  if (strcmp(name_inVAR_SHORT_NAME)) ERR;
392  if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
393  if (xtype_in != NC_BYTEERR;
394  if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
395  if (xtype_in != NC_CHARERR;
396  if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
397  if (xtype_in != NC_SHORTERR;
398
399  /* Check inquire of atomic types */
400  if (nc_inq_type(ncidNC_BYTEname_in, &size_in)) ERR;
401  if (strcmp(name_in, "byte") || size_in != sizeof(char)) ERR;
402  if (nc_inq_type(ncidNC_CHARname_in, &size_in)) ERR;
403  if (strcmp(name_in, "char") || size_in != sizeof(char)) ERR;
404  if (nc_inq_type(ncidNC_SHORTname_in, &size_in)) ERR;
405  if (strcmp(name_in, "short") || size_in != sizeof(short)) ERR;
406  if (nc_inq_type(ncidNC_INTname_in, &size_in)) ERR;
407  if (strcmp(name_in, "int") || size_in != sizeof(int)) ERR;
408  if (nc_inq_type(ncidNC_FLOATname_in, &size_in)) ERR;
409  if (strcmp(name_in, "float") || size_in != sizeof(float)) ERR;
410  if (nc_inq_type(ncidNC_DOUBLEname_in, &size_in)) ERR;
411  if (strcmp(name_in, "double") || size_in != sizeof(double)) ERR;
412  if (nc_inq_type(ncidNC_UBYTEname_in, &size_in)) ERR;
413  if (strcmp(name_in, "ubyte") || size_in != sizeof(unsigned char)) ERR;
414  if (nc_inq_type(ncidNC_USHORTname_in, &size_in)) ERR;
415  if (strcmp(name_in, "ushort") || size_in != sizeof(unsigned short)) ERR;
416  if (nc_inq_type(ncidNC_UINTname_in, &size_in)) ERR;
417  if (strcmp(name_in, "uint") || size_in != sizeof(unsigned int)) ERR;
418  if (nc_inq_type(ncidNC_INT64name_in, &size_in)) ERR;
419  if (strcmp(name_in, "int64") || size_in != sizeof(long long)) ERR;
420  if (nc_inq_type(ncidNC_UINT64name_in, &size_in)) ERR;
421  if (strcmp(name_in, "uint64") || size_in != sizeof(unsigned long long)) ERR;
422  if (nc_inq_type(ncidNC_STRINGname_in, &size_in)) ERR;
423  if (strcmp(name_in, "string") || size_in != sizeof(char *)) ERR;
424
425  if (nc_inq_typeid(ncid, "byte", &xtype_in)) ERR;
426  if (xtype_in != NC_BYTEERR;
427  if (nc_inq_typeid(ncid, "char", &xtype_in)) ERR;
428  if (xtype_in != NC_CHARERR;
429  if (nc_inq_typeid(ncid, "short", &xtype_in)) ERR;
430  if (xtype_in != NC_SHORTERR;
431  if (nc_inq_typeid(ncid, "int", &xtype_in)) ERR;
432  if (xtype_in != NC_INTERR;
433  if (nc_inq_typeid(ncid, "float", &xtype_in)) ERR;
434  if (xtype_in != NC_FLOATERR;
435  if (nc_inq_typeid(ncid, "double", &xtype_in)) ERR;
436  if (xtype_in != NC_DOUBLEERR;
437  if (nc_inq_typeid(ncid, "ubyte", &xtype_in)) ERR;
438  if (xtype_in != NC_UBYTEERR;
439  if (nc_inq_typeid(ncid, "ushort", &xtype_in)) ERR;
440  if (xtype_in != NC_USHORTERR;
441  if (nc_inq_typeid(ncid, "uint", &xtype_in)) ERR;
442  if (xtype_in != NC_UINTERR;
443  if (nc_inq_typeid(ncid, "int64", &xtype_in)) ERR;
444  if (xtype_in != NC_INT64ERR;
445  if (nc_inq_typeid(ncid, "uint64", &xtype_in)) ERR;
446  if (xtype_in != NC_UINT64ERR;
447  if (nc_inq_typeid(ncid, "string", &xtype_in)) ERR;
448  if (xtype_in != NC_STRINGERR;
449
450  if (nc_close(ncid)) ERR;
451      }
452
453      /* Open the file and check data. */
454      if (nc_open(FILE_NAME, 0, &ncid)) ERR;
455      if (nc_get_var_schar(ncidbyte_varid, (signed char *)byte_in)) ERR;
456      for (i = 0; i < DIM1_LENi++)
457  for (j = 0; j < DIM2_LENj++)
458     if (byte_in[i][j] != byte_out[i][j]) ERR;
459      if (nc_get_var_short(ncidshort_varid, (short *)short_in)) ERR;
460      for (i = 0; i < DIM1_LENi++)
461  for (j = 0; j < DIM2_LENj++)
462     if (short_in[i][j] != short_out[i][j]) ERR;
463      if (nc_get_var_int(ncidint_varid, (int *)int_in)) ERR;
464      for (i = 0; i < DIM1_LENi++)
465  for (j = 0; j < DIM2_LENj++)
466     if (int_in[i][j] != int_out[i][j]) ERR;
467      if (nc_get_var_float(ncidfloat_varid, (float *)float_in)) ERR;
468      for (i = 0; i < DIM1_LENi++)
469  for (j = 0; j < DIM2_LENj++)
470     if (float_in[i][j] != float_out[i][j]) ERR;
471      if (nc_get_var_double(nciddouble_varid, (double *)double_in)) ERR;
472      for (i = 0; i < DIM1_LENi++)
473  for (j = 0; j < DIM2_LENj++)
474     if (double_in[i][j] != double_out[i][j]) ERR;
475      if (nc_get_var_double(nciddouble_varid, (double *)double_in)) ERR;
476      for (i = 0; i < DIM1_LENi++)
477  for (j = 0; j < DIM2_LENj++)
478     if (double_in[i][j] != double_out[i][j]) ERR;
479      if (nc_get_var_double(nciddouble_varid, (double *)double_in)) ERR;
480      for (i = 0; i < DIM1_LENi++)
481  for (j = 0; j < DIM2_LENj++)
482     if (double_in[i][j] != double_out[i][j]) ERR;
483      if (nc_get_var_uint(nciduint_varid, (unsigned int *)uint_in)) ERR;
484      for (i = 0; i < DIM1_LENi++)
485  for (j = 0; j < DIM2_LENj++)
486     if (uint_in[i][j] != uint_out[i][j]) ERR;
487      if (nc_get_var_longlong(ncidint64_varid, (long long *)int64_in)) ERR;
488      for (i = 0; i < DIM1_LENi++)
489  for (j = 0; j < DIM2_LENj++)
490     if (int64_in[i][j] != int64_out[i][j]) ERR;
491      if (nc_get_var_ulonglong(nciduint64_varid, (unsigned long long *)uint64_in)) ERR;
492      for (i = 0; i < DIM1_LENi++)
493  for (j = 0; j < DIM2_LENj++)
494     if (uint64_in[i][j] != uint64_out[i][j]) ERR;
495      if (nc_close(ncid)) ERR;
496
497      /* Open the file and read everything as double. */
498      if (nc_open(FILE_NAME, 0, &ncid)) ERR;
499      if (nc_get_var_double(ncidbyte_varid, (double *)double_in)) ERR;
500      for (i = 0; i < DIM1_LENi++)
501  for (j = 0; j < DIM2_LENj++)
502     if (double_in[i][j] != (double)byte_out[i][j]) ERR;
503      if (nc_get_var_double(ncidubyte_varid, (double *)double_in)) ERR;
504      for (i = 0; i < DIM1_LENi++)
505  for (j = 0; j < DIM2_LENj++)
506     if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
507      if (nc_get_var_double(ncidshort_varid, (double *)double_in)) ERR;
508      for (i = 0; i < DIM1_LENi++)
509  for (j = 0; j < DIM2_LENj++)
510     if (double_in[i][j] != (double)short_out[i][j]) ERR;
511      if (nc_get_var_double(ncidushort_varid, (double *)double_in)) ERR;
512      for (i = 0; i < DIM1_LENi++)
513  for (j = 0; j < DIM2_LENj++)
514     if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
515      if (nc_get_var_double(ncidint_varid, (double *)double_in)) ERR;
516      for (i = 0; i < DIM1_LENi++)
517  for (j = 0; j < DIM2_LENj++)
518     if (double_in[i][j] != (double)int_out[i][j]) ERR;
519      if (nc_get_var_double(nciduint_varid, (double *)double_in)) ERR;
520      for (i = 0; i < DIM1_LENi++)
521  for (j = 0; j < DIM2_LENj++)
522     if (double_in[i][j] != (double)uint_out[i][j]) ERR;
523      if (nc_get_var_double(ncidfloat_varid, (double *)double_in)) ERR;
524      for (i = 0; i < DIM1_LENi++)
525  for (j = 0; j < DIM2_LENj++)
526     if (double_in[i][j] != (double)float_out[i][j]) ERR;
527      if (nc_get_var_double(ncidint64_varid, (double *)double_in)) ERR;
528      for (i = 0; i < DIM1_LENi++)
529  for (j = 0; j < DIM2_LENj++)
530     if (double_in[i][j] != (double)int64_out[i][j]) ERR;
531      if (nc_get_var_double(nciduint64_varid, (double *)double_in)) ERR;
532      for (i = 0; i < DIM1_LENi++)
533  for (j = 0; j < DIM2_LENj++)
534     if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
535      if (nc_close(ncid)) ERR;
536
537      /* Open the file and read everything as NC_BYTE. */
538      if (nc_open(FILE_NAME, 0, &ncid)) ERR;
539      if (nc_get_var_schar(ncidbyte_varid, (signed char *)byte_in)) ERR;
540      for (i = 0; i < DIM1_LENi++)
541  for (j = 0; j < DIM2_LENj++)
542     if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
543      if (nc_get_var_schar(ncidubyte_varid, (signed char *)byte_in) != NC_ERANGEERR;
544      for (i = 0; i < DIM1_LENi++)
545  for (j = 0; j < DIM2_LENj++)
546     if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
547      if (nc_get_var_schar(ncidshort_varid, (signed char *)byte_in) != NC_ERANGEERR;
548      for (i = 0; i < DIM1_LENi++)
549  for (j = 0; j < DIM2_LENj++)
550     if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
551      if (nc_get_var_schar(ncidushort_varid, (signed char *)byte_in) != NC_ERANGEERR;
552      for (i = 0; i < DIM1_LENi++)
553  for (j = 0; j < DIM2_LENj++)
554     if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
555      if (nc_get_var_schar(ncidint_varid, (signed char *)byte_in) != NC_ERANGEERR;
556      for (i = 0; i < DIM1_LENi++)
557  for (j = 0; j < DIM2_LENj++)
558     if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
559      if (nc_get_var_schar(nciduint_varid, (signed char *)byte_in) != NC_ERANGEERR;
560      for (i = 0; i < DIM1_LENi++)
561  for (j = 0; j < DIM2_LENj++)
562     if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
563      if (nc_get_var_schar(ncidfloat_varid, (signed char *)byte_in) != NC_ERANGEERR;
564      for (i = 0; i < DIM1_LENi++)
565  for (j = 0; j < DIM2_LENj++)
566     if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
567      if (nc_get_var_schar(ncidint64_varid, (signed char *)byte_in) != NC_ERANGEERR;
568      for (i = 0; i < DIM1_LENi++)
569  for (j = 0; j < DIM2_LENj++)
570     if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
571      if (nc_get_var_schar(nciduint64_varid, (signed char *)byte_in) != NC_ERANGEERR;
572      for (i = 0; i < DIM1_LENi++)
573  for (j = 0; j < DIM2_LENj++)
574     if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
575      if (nc_close(ncid)) ERR;
576   }
577   SUMMARIZE_ERR;
578
579#define DEFLATE_LEVEL_4 4
580
581   printf("*** testing simple variables with deflation...");
582   {
583      /* Create a file with a variable of each type. */
584      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
585      if (nc_def_dim(ncidDIM1_NAMEDIM1_LEN, &dimids[0])) ERR;
586      if (nc_def_dim(ncidDIM2_NAMEDIM2_LEN, &dimids[1])) ERR;
587      if (nc_def_dim(ncidDIM3_NAMEDIM3_LEN, &dimids[2])) ERR;
588      if (nc_def_var(ncidVAR_BYTE_NAMENC_BYTE, 2, dimids, &byte_varid)) ERR;
589      if (nc_def_var_deflate(ncidbyte_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
590      if (nc_def_var(ncidVAR_CHAR_NAMENC_CHAR, 3, dimids, &char_varid)) ERR;
591      if (nc_def_var_deflate(ncidbyte_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
592      if (nc_def_var(ncidVAR_SHORT_NAMENC_SHORT, 2, dimids, &short_varid)) ERR;
593      if (nc_def_var_deflate(ncidshort_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
594      if (nc_def_var(ncidVAR_INT_NAMENC_INT, 2, dimids, &int_varid)) ERR;
595      if (nc_def_var_deflate(ncidint_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
596      if (nc_def_var(ncidVAR_FLOAT_NAMENC_FLOAT, 2, dimids, &float_varid)) ERR;
597      if (nc_def_var_deflate(ncidfloat_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
598      if (nc_def_var(ncidVAR_DOUBLE_NAMENC_DOUBLE, 2, dimids, &double_varid)) ERR;
599      if (nc_def_var_deflate(nciddouble_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
600      if (nc_def_var(ncidVAR_UBYTE_NAMENC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
601      if (nc_def_var_deflate(ncidubyte_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
602      if (nc_def_var(ncidVAR_USHORT_NAMENC_USHORT, 2, dimids, &ushort_varid)) ERR;
603      if (nc_def_var_deflate(ncidushort_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
604      if (nc_def_var(ncidVAR_UINT_NAMENC_UINT, 2, dimids, &uint_varid)) ERR;
605      if (nc_def_var_deflate(nciduint_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
606      if (nc_def_var(ncidVAR_INT64_NAMENC_INT64, 2, dimids, &int64_varid)) ERR;
607      if (nc_def_var_deflate(ncidint64_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
608      if (nc_def_var(ncidVAR_UINT64_NAMENC_UINT64, 2, dimids, &uint64_varid)) ERR;
609      if (nc_def_var_deflate(nciduint64_varidNC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
610
611      if (nc_put_var_schar(ncidbyte_varid, (signed char *)byte_out)) ERR_RET;
612      if (nc_put_var_text(ncidchar_varid, (char *)char_out)) ERR;
613      if (nc_put_var_short(ncidshort_varid, (short *)short_out)) ERR;
614      if (nc_put_var_int(ncidint_varid, (int *)int_out)) ERR;
615      if (nc_put_var_float(ncidfloat_varid, (float *)float_out)) ERR;
616      if (nc_put_var_double(nciddouble_varid, (double *)double_out)) ERR;
617      if (nc_put_var_uchar(ncidubyte_varid, (unsigned char *)ubyte_out)) ERR;
618      if (nc_put_var_ushort(ncidushort_varid, (unsigned short *)ushort_out)) ERR;
619      if (nc_put_var_uint(nciduint_varid, (unsigned int *)uint_out)) ERR;
620      if (nc_put_var_longlong(ncidint64_varid, (long long *)int64_out)) ERR;
621      if (nc_put_var_ulonglong(nciduint64_varid, (unsigned long long *)uint64_out)) ERR;
622      if (nc_close(ncid)) ERR;
623
624      /* Open the file and check metadata. */
625      {
626  nc_type xtype_in;
627  int ndims_indimids_in[10], natts_invarid_in;
628  char name_in[NC_MAX_NAME+1];
629
630  if (nc_open(FILE_NAME, 0, &ncid)) ERR;
631  if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_indimids_in,
632 &natts_in)) ERR;
633  if (strcmp(name_inVAR_BYTE_NAME) || xtype_in != NC_BYTE ||
634      ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
635      dimids_in[1] != dimids[1]) ERR;
636  if (nc_inq_varid(ncidVAR_BYTE_NAME, &varid_in)) ERR;
637  if (varid_in != 0) ERR;
638  if (nc_inq_varid(ncidVAR_CHAR_NAME, &varid_in)) ERR;
639  if (varid_in != 1) ERR;
640  if (nc_inq_varid(ncidVAR_SHORT_NAME, &varid_in)) ERR;
641  if (varid_in != 2) ERR;
642  if (nc_inq_varname(ncid, 0, name_in)) ERR;
643  if (strcmp(name_inVAR_BYTE_NAME)) ERR;
644  if (nc_inq_varname(ncid, 1, name_in)) ERR;
645  if (strcmp(name_inVAR_CHAR_NAME)) ERR;
646  if (nc_inq_varname(ncid, 2, name_in)) ERR;
647  if (strcmp(name_inVAR_SHORT_NAME)) ERR;
648  if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
649  if (xtype_in != NC_BYTEERR;
650  if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
651  if (xtype_in != NC_CHARERR;
652  if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
653  if (xtype_in != NC_SHORTERR;
654  if (nc_close(ncid)) ERR;
655      }
656
657      /* Open the file and check data. */
658      if (nc_open(FILE_NAME, 0, &ncid)) ERR;
659      if (nc_get_var_schar(ncidbyte_varid, (signed char *)byte_in)) ERR;
660      for (i = 0; i < DIM1_LENi++)
661  for (j = 0; j < DIM2_LENj++)
662     if (byte_in[i][j] != byte_out[i][j]) ERR;
663      if (nc_get_var_short(ncidshort_varid, (short *)short_in)) ERR;
664      for (i = 0; i < DIM1_LENi++)
665  for (j = 0; j < DIM2_LENj++)
666     if (short_in[i][j] != short_out[i][j]) ERR;
667      if (nc_get_var_int(ncidint_varid, (int *)int_in)) ERR;
668      for (i = 0; i < DIM1_LENi++)
669  for (j = 0; j < DIM2_LENj++)
670     if (int_in[i][j] != int_out[i][j]) ERR;
671      if (nc_get_var_float(ncidfloat_varid, (float *)float_in)) ERR;
672      for (i = 0; i < DIM1_LENi++)
673  for (j = 0; j < DIM2_LENj++)
674     if (float_in[i][j] != float_out[i][j]) ERR;
675      if (nc_get_var_double(nciddouble_varid, (double *)double_in)) ERR;
676      for (i = 0; i < DIM1_LENi++)
677  for (j = 0; j < DIM2_LENj++)
678     if (double_in[i][j] != double_out[i][j]) ERR;
679      if (nc_get_var_double(nciddouble_varid, (double *)double_in)) ERR;
680      for (i = 0; i < DIM1_LENi++)
681  for (j = 0; j < DIM2_LENj++)
682     if (double_in[i][j] != double_out[i][j]) ERR;
683      if (nc_get_var_double(nciddouble_varid, (double *)double_in)) ERR;
684      for (i = 0; i < DIM1_LENi++)
685  for (j = 0; j < DIM2_LENj++)
686     if (double_in[i][j] != double_out[i][j]) ERR;
687      if (nc_get_var_uint(nciduint_varid, (unsigned int *)uint_in)) ERR;
688      for (i = 0; i < DIM1_LENi++)
689  for (j = 0; j < DIM2_LENj++)
690     if (uint_in[i][j] != uint_out[i][j]) ERR;
691      if (nc_get_var_longlong(ncidint64_varid, (long long *)int64_in)) ERR;
692      for (i = 0; i < DIM1_LENi++)
693  for (j = 0; j < DIM2_LENj++)
694     if (int64_in[i][j] != int64_out[i][j]) ERR;
695      if (nc_get_var_ulonglong(nciduint64_varid, (unsigned long long *)uint64_in)) ERR;
696      for (i = 0; i < DIM1_LENi++)
697  for (j = 0; j < DIM2_LENj++)
698     if (uint64_in[i][j] != uint64_out[i][j]) ERR;
699      if (nc_close(ncid)) ERR;
700
701      /* Open the file and read everything as double. */
702      if (nc_open(FILE_NAME, 0, &ncid)) ERR;
703      if (nc_get_var_double(ncidbyte_varid, (double *)double_in)) ERR;
704      for (i = 0; i < DIM1_LENi++)
705  for (j = 0; j < DIM2_LENj++)
706     if (double_in[i][j] != (double)byte_out[i][j]) ERR;
707      if (nc_get_var_double(ncidubyte_varid, (double *)double_in)) ERR;
708      for (i = 0; i < DIM1_LENi++)
709  for (j = 0; j < DIM2_LENj++)
710     if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
711      if (nc_get_var_double(ncidshort_varid, (double *)double_in)) ERR;
712      for (i = 0; i < DIM1_LENi++)
713  for (j = 0; j < DIM2_LENj++)
714     if (double_in[i][j] != (double)short_out[i][j]) ERR;
715      if (nc_get_var_double(ncidushort_varid, (double *)double_in)) ERR;
716      for (i = 0; i < DIM1_LENi++)
717  for (j = 0; j < DIM2_LENj++)
718     if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
719      if (nc_get_var_double(ncidint_varid, (double *)double_in)) ERR;
720      for (i = 0; i < DIM1_LENi++)
721  for (j = 0; j < DIM2_LENj++)
722     if (double_in[i][j] != (double)int_out[i][j]) ERR;
723      if (nc_get_var_double(nciduint_varid, (double *)double_in)) ERR;
724      for (i = 0; i < DIM1_LENi++)
725  for (j = 0; j < DIM2_LENj++)
726     if (double_in[i][j] != (double)uint_out[i][j]) ERR;
727      if (nc_get_var_double(ncidfloat_varid, (double *)double_in)) ERR;
728      for (i = 0; i < DIM1_LENi++)
729  for (j = 0; j < DIM2_LENj++)
730     if (double_in[i][j] != (double)float_out[i][j]) ERR;
731      if (nc_get_var_double(ncidint64_varid, (double *)double_in)) ERR;
732      for (i = 0; i < DIM1_LENi++)
733  for (j = 0; j < DIM2_LENj++)
734     if (double_in[i][j] != (double)int64_out[i][j]) ERR;
735      if (nc_get_var_double(nciduint64_varid, (double *)double_in)) ERR;
736      for (i = 0; i < DIM1_LENi++)
737  for (j = 0; j < DIM2_LENj++)
738     if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
739      if (nc_close(ncid)) ERR;
740
741      /* Open the file and read everything as NC_BYTE. */
742      if (nc_open(FILE_NAME, 0, &ncid)) ERR;
743      if (nc_get_var_schar(ncidbyte_varid, (signed char *)byte_in)) ERR;
744      for (i = 0; i < DIM1_LENi++)
745  for (j = 0; j < DIM2_LENj++)
746     if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
747      if (nc_get_var_schar(ncidubyte_varid, (signed char *)byte_in) != NC_ERANGEERR;
748      for (i = 0; i < DIM1_LENi++)
749  for (j = 0; j < DIM2_LENj++)
750     if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
751      if (nc_get_var_schar(ncidshort_varid, (signed char *)byte_in) != NC_ERANGEERR;
752      for (i = 0; i < DIM1_LENi++)
753  for (j = 0; j < DIM2_LENj++)
754     if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
755      if (nc_get_var_schar(ncidushort_varid, (signed char *)byte_in) != NC_ERANGEERR;
756      for (i = 0; i < DIM1_LENi++)
757  for (j = 0; j < DIM2_LENj++)
758     if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
759      if (nc_get_var_schar(ncidint_varid, (signed char *)byte_in) != NC_ERANGEERR;
760      for (i = 0; i < DIM1_LENi++)
761  for (j = 0; j < DIM2_LENj++)
762     if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
763      if (nc_get_var_schar(nciduint_varid, (signed char *)byte_in) != NC_ERANGEERR;
764      for (i = 0; i < DIM1_LENi++)
765  for (j = 0; j < DIM2_LENj++)
766     if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
767      if (nc_get_var_schar(ncidfloat_varid, (signed char *)byte_in) != NC_ERANGEERR;
768      for (i = 0; i < DIM1_LENi++)
769  for (j = 0; j < DIM2_LENj++)
770     if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
771      if (nc_get_var_schar(ncidint64_varid, (signed char *)byte_in) != NC_ERANGEERR;
772      for (i = 0; i < DIM1_LENi++)
773  for (j = 0; j < DIM2_LENj++)
774     if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
775      if (nc_get_var_schar(nciduint64_varid, (signed char *)byte_in) != NC_ERANGEERR;
776      for (i = 0; i < DIM1_LENi++)
777  for (j = 0; j < DIM2_LENj++)
778     if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
779      if (nc_close(ncid)) ERR;
780
781   }
782   SUMMARIZE_ERR;
783
784#define NDIMS4 1
785#define NVARS4 1
786#define DIM4_NAME "treaty_of_paris_1783"
787#define DIM4_LEN 5
788#define VAR_NAME4 "John_Adams"
789#define DEFLATE_LEVEL 6
790
791   printf("*** testing netcdf-4 simple variable define...");
792   {
793      int dimids[NDIMS4], dimids_in[NDIMS4];
794      int varidvarids_in[NVARS4];
795      int ndimsnvarsnattsunlimdimid;
796      nc_type xtype_in;
797      char name_in[NC_MAX_NAME + 1];
798      int shuffle_indeflate_indeflate_level;
799
800      /* Create a netcdf-4 file with one dim and one var. */
801      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
802      if (nc_def_dim(ncidDIM4_NAMEDIM4_LEN, &dimids[0])) ERR;
803      if (dimids[0] != 0) ERR;
804      if (nc_def_var(ncidVAR_NAME4NC_INT64NDIMS4dimids, &varid)) ERR;
805      if (nc_def_var_deflate(ncidvaridNC_NOSHUFFLE, 1, DEFLATE_LEVEL)) ERR;
806      if (varid != 0) ERR;
807
808      /* Check stuff. */
809      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
810      if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
811   unlimdimid != -1) ERR;
812      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
813      if (nvars != NVARS4ERR;
814      if (varids_in[0] != 0) ERR;
815      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
816      dimids_in, &natts)) ERR;
817      if (strcmp(name_inVAR_NAME4) || xtype_in != NC_INT64 ||
818   ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
819      if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
820      &deflate_level)) ERR;
821      if (shuffle_in != NC_NOSHUFFLE ||!deflate_in ||
822   deflate_level != DEFLATE_LEVELERR;
823
824      if (nc_close(ncid)) ERR;
825
826      /* Open the file and check the same stuff. */
827      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
828
829      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
830      if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
831   unlimdimid != -1) ERR;
832      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
833      if (nvars != NVARS4ERR;
834      if (varids_in[0] != 0) ERR;
835      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
836      dimids_in, &natts)) ERR;
837      if (strcmp(name_inVAR_NAME4) || xtype_in != NC_INT64 ||
838   ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
839      if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
840      &deflate_level)) ERR;
841      if (shuffle_in != NC_NOSHUFFLE ||!deflate_in ||
842   deflate_level != DEFLATE_LEVELERR;
843
844      if (nc_close(ncid)) ERR;
845   }
846
847   SUMMARIZE_ERR;
848
849#define NDIMS5 1
850#define NVARS5 5
851#define DIM5_NAME "treaty_of_paris_1783"
852#define DIM5_LEN 5
853
854   printf("*** testing netcdf-4 less simple variable define...");
855   {
856      int dimids[NDIMS5], dimids_in[NDIMS5];
857      int varid[NVARS5], varids_in[NVARS5];
858      int ndimsnvarsnattsunlimdimid;
859      nc_type xtype_in;
860      char name_in[NC_MAX_NAME + 1];
861      char var_name[NVARS5][NC_MAX_NAME + 1] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
862 "Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
863 "Charles_F_Ritchel"};
864      int shuffle_indeflate_indeflate_level_in;
865      int deflate_level[NVARS5];
866      int i;
867
868      /* Set up options for this var. */
869      for (i = 0; i < NVARS5i++)
870  deflate_level[i] = i;
871
872      /* Create a netcdf-4 file with one dim and two vars. */
873      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
874      if (nc_def_dim(ncidDIM5_NAMEDIM5_LEN, &dimids[0])) ERR;
875      if (dimids[0] != 0) ERR;
876      for (i = 0; i < NVARS5i++)
877      {
878  if (nc_def_var(ncidvar_name[i], NC_INT64NDIMS5dimids,
879 &varid[i])) ERR;
880  if (varid[i] != iERR;
881  if (nc_def_var_deflate(ncidvarid[i], NC_SHUFFLE, 1, deflate_level[i])) ERR;
882      }
883
884      /* Check stuff. */
885      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
886      if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
887   unlimdimid != -1) ERR;
888      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
889      if (nvars != NVARS5ERR;
890      for (i = 0; i < NVARS5i++)
891      {
892  if (varids_in[i] != iERR;
893  if (nc_inq_var(ncidiname_in, &xtype_in, &ndims,
894 dimids_in, &natts)) ERR;
895  if (strcmp(name_invar_name[i]) || xtype_in != NC_INT64 ||
896      ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
897  if (nc_inq_var_deflate(ncidvarid[i], &shuffle_in, &deflate_in,
898 &deflate_level_in)) ERR;
899  if (shuffle_in != NC_SHUFFLE || !deflate_in ||
900      deflate_level_in != deflate_level[i]) ERR;
901      }
902
903      if (nc_close(ncid)) ERR;
904
905      /* Open the file and check the same stuff. */
906      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
907
908      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
909      if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
910   unlimdimid != -1) ERR;
911      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
912      if (nvars != NVARS5ERR;
913      for (i = 0; i < NVARS5i++)
914      {
915  if (varids_in[i] != iERR;
916  if (nc_inq_var(ncidiname_in, &xtype_in, &ndims,
917 dimids_in, &natts)) ERR;
918  if (strcmp(name_invar_name[i]) || xtype_in != NC_INT64 ||
919      ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
920  if (nc_inq_var_deflate(ncidvarid[i], &shuffle_in, &deflate_in,
921 &deflate_level_in)) ERR;
922  if (shuffle_in != NC_SHUFFLE || !deflate_in ||
923      deflate_level_in != deflate_level[i]) ERR;
924      }
925
926      if (nc_close(ncid)) ERR;
927   }
928
929   SUMMARIZE_ERR;
930
931#define NVARS 5
932#define NDIMS 1
933#define DIM6_NAME "airship_cross_sectional_area"
934#define DIM6_LEN 100
935#define TEN_K_M2 10000.0
936#define INCREMENT 1000.0
937
938   printf("*** testing more complex netcdf-4 variable defines...");
939   {
940      int dimids[NDIMS], dimids_in[NDIMS];
941      int varid[NVARS], varids_in[NVARS];
942      int ndimsnvarsnattsunlimdimid;
943      char var_name[NVARS][50] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
944   "Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
945   "Charles_F_Ritchel"};
946      double data[DIM6_LEN];
947      nc_type xtype_in;
948      char name_in[NC_MAX_NAME + 1];
949      int shuffle_indeflate_indeflate_level_in;
950      int checksum_in;
951      int i;
952
953      /* Create some phoney data. */
954      for (i = 1, data[0] = TEN_K_M2i < DIM6_LENi++)
955  data[i] = data[i - 1] + INCREMENT;
956
957      /* Create a netcdf-4 file with one dim and 5 NC_DOUBLE vars. */
958      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
959      if (nc_def_dim(ncidDIM6_NAMEDIM6_LEN, &dimids[0])) ERR;
960      for (i = 0; i < NVARSi++)
961      {
962  if (nc_def_var(ncidvar_name[i], NC_DOUBLENDIMSdimids,
963 &varid[i])) ERR;
964  if (nc_def_var_deflate(ncidvarid[i], NC_NOSHUFFLE, 1, 0)) ERR;
965  if (nc_def_var_fletcher32(ncidvarid[i], NC_FLETCHER32)) ERR;
966      }
967
968      /* Check stuff. */
969      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
970      if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
971   unlimdimid != -1) ERR;
972      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
973      if (nvars != NVARSERR;
974      for (i = 0; i < NVARSi++)
975  if (varids_in[i] != iERR;
976      for (i = 0; i < NVARSi++)
977      {
978  if (nc_inq_var(ncidiname_in, &xtype_in, &ndims,
979 dimids_in, &natts)) ERR;
980  if (strcmp(name_invar_name[i]) || xtype_in != NC_DOUBLE ||
981      ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
982  if (nc_inq_var_deflate(ncidvarid[i], &shuffle_in, &deflate_in,
983 &deflate_level_in)) ERR;
984  if (shuffle_in != NC_NOSHUFFLE || !deflate_in || deflate_level_in != 0) ERR;
985  if (nc_inq_var_fletcher32(ncidvarid[i], &checksum_in)) ERR;
986  if (checksum_in != NC_FLETCHER32ERR;
987      }
988
989      if (nc_close(ncid)) ERR;
990
991      /* Open the file and check the same stuff. */
992      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
993      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
994      if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
995   unlimdimid != -1) ERR;
996      if (nc_inq_varids(ncid, &nvarsvarids_in)) ERR;
997      if (nvars != NVARSERR;
998      for (i = 0; i < NVARSi++)
999  if (varids_in[i] != iERR;
1000      for (i = 0; i < NVARSi++)
1001      {
1002  if (nc_inq_var(ncidiname_in, &xtype_in, &ndims,
1003 dimids_in, &natts)) ERR;
1004  if (strcmp(name_invar_name[i]) || xtype_in != NC_DOUBLE ||
1005      ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
1006  if (nc_inq_var_deflate(ncidvarid[i], &shuffle_in, &deflate_in,
1007 &deflate_level_in)) ERR;
1008  if (shuffle_in != NC_NOSHUFFLE || !deflate_in ||
1009      deflate_level_in != 0) ERR;
1010  if (nc_inq_var_fletcher32(ncidvarid[i], &checksum_in)) ERR;
1011  if (checksum_in != NC_FLETCHER32ERR;
1012      }
1013
1014      if (nc_close(ncid)) ERR;
1015   }
1016
1017   SUMMARIZE_ERR;
1018#define DIM7_LEN 2
1019#define DIM7_NAME "dim_7_from_Indiana"
1020#define VAR7_NAME "var_7_from_Idaho"
1021#define NDIMS 1
1022
1023   printf("*** testing fill values...");
1024   {
1025      int dimids[NDIMS], dimids_in[NDIMS];
1026      size_t index[NDIMS];
1027      int varidndimsnatts;
1028      nc_type xtype_in;
1029      char name_in[NC_MAX_NAME + 1];
1030      int shuffle_indeflate_indeflate_level_in;
1031      int checksum_inno_fill;
1032      unsigned short ushort_data = 42, ushort_data_infill_value_in;
1033
1034      /* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
1035      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
1036      if (nc_def_dim(ncidDIM7_NAMEDIM7_LEN, &dimids[0])) ERR;
1037      if (nc_def_var(ncidVAR7_NAMENC_USHORTNDIMSdimids,
1038      &varid)) ERR;
1039
1040      /* Check stuff. */
1041      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
1042      dimids_in, &natts)) ERR;
1043      if (strcmp(name_inVAR7_NAME) || xtype_in != NC_USHORT ||
1044   ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
1045      if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
1046      &deflate_level_in)) ERR;
1047      if (shuffle_in != NC_NOSHUFFLE || deflate_inERR;
1048      if (nc_inq_var_fletcher32(ncid, 0, &checksum_in)) ERR;
1049      if (checksum_in != NC_NOCHECKSUMERR;
1050      if (nc_inq_var_fill(ncid, 0, &no_fill, &fill_value_in)) ERR;
1051      if (no_fill || fill_value_in != NC_FILL_USHORTERR;
1052
1053      /* Write the second of two values. */
1054      index[0] = 1;
1055      if (nc_put_var1_ushort(ncid, 0, index, &ushort_data)) ERR;
1056
1057      /* Get the first value, and make sure we get the default fill
1058       * value for USHORT. */
1059      index[0] = 0;
1060      if (nc_get_var1_ushort(ncid, 0, index, &ushort_data_in)) ERR;
1061      if (ushort_data_in != NC_FILL_USHORTERR;
1062
1063      if (nc_close(ncid)) ERR;
1064
1065      /* Open the file and check the same stuff. */
1066      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
1067
1068      /* Check stuff. */
1069      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
1070      dimids_in, &natts)) ERR;
1071      if (strcmp(name_inVAR7_NAME) || xtype_in != NC_USHORT ||
1072   ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
1073      if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
1074      &deflate_level_in)) ERR;
1075      if (shuffle_in != NC_NOSHUFFLE || deflate_inERR;
1076      if (nc_inq_var_fletcher32(ncid, 0, &checksum_in)) ERR;
1077      if (checksum_in != NC_NOCHECKSUMERR;
1078
1079      if (nc_close(ncid)) ERR;
1080   }
1081
1082   SUMMARIZE_ERR;
1083   printf("*** testing more fill values...");
1084   {
1085      int dimids[NDIMS];
1086      size_t index[NDIMS];
1087      int varid;
1088      int no_fill;
1089      unsigned short ushort_data = 42, ushort_data_infill_value_in;
1090
1091      /* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
1092      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
1093      if (nc_def_dim(ncidDIM7_NAMEDIM7_LEN, &dimids[0])) ERR;
1094      if (nc_def_var(ncidVAR7_NAMENC_USHORTNDIMSdimids,
1095      &varid)) ERR;
1096      if (nc_def_var_fill(ncidvarid, 1, NULL)) ERR;
1097
1098      /* Check stuff. */
1099      if (nc_inq_var_fill(ncidvarid, &no_fill, &fill_value_in)) ERR;
1100      if (!no_fillERR;
1101
1102      /* Write the second of two values. */
1103      index[0] = 1;
1104      if (nc_put_var1_ushort(ncidvaridindex, &ushort_data)) ERR;
1105
1106      /* Get the first value, and make sure we get the default fill
1107       * value for USHORT. */
1108      index[0] = 0;
1109      if (nc_get_var1_ushort(ncidvaridindex, &ushort_data_in)) ERR;
1110
1111      if (nc_close(ncid)) ERR;
1112
1113      /* Open the file and check the same stuff. */
1114      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
1115
1116      /* Check stuff. */
1117      if (nc_inq_var_fill(ncidvarid, &no_fill, &fill_value_in)) ERR;
1118      if (!no_fillERR;
1119
1120      if (nc_close(ncid)) ERR;
1121   }
1122
1123   SUMMARIZE_ERR;
1124   printf("*** testing fill values for 2D unlimited dimension variable...");
1125   {
1126#define D1_NAME "unlimited"
1127#define D1_TARGET 3
1128#define D2_NAME "fixed"
1129#define D2_LEN 3
1130#define D2_TARGET 2
1131#define V1_NAME "var1"
1132#define ND1 2
1133#define TARGET_VALUE 42
1134
1135      int dimids[ND1];
1136      size_t index[ND1];
1137      int varid;
1138      int no_fill;
1139      int data = TARGET_VALUEdata_in[D1_TARGET][D2_LEN], fill_value_in;
1140      int ij;
1141
1142      /* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
1143      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
1144      if (nc_def_dim(ncidD1_NAMENC_UNLIMITED, &dimids[0])) ERR;
1145      if (nc_def_dim(ncidD2_NAMED2_LEN, &dimids[1])) ERR;
1146      if (nc_def_var(ncidV1_NAMENC_INTND1dimids, &varid)) ERR;
1147
1148      /* Check stuff. */
1149      if (nc_inq_var_fill(ncidvarid, &no_fill, &fill_value_in)) ERR;
1150      if (no_fillERR;
1151
1152      /* Write a value. */
1153      index[0] = D1_TARGET;
1154      index[1] = D2_TARGET;
1155      if (nc_put_var1_int(ncidvaridindex, &data)) ERR;
1156
1157      /* Get the data, and check the values. */
1158      if (nc_get_var_int(ncid, 0, &data_in[0][0])) ERR;
1159      for (i = 0; i < D1_TARGETi++)
1160  for (j = 0; j < D2_LENj++)
1161     if ((i == D1_TARGET && j == D2_TARGET && data_in[i][j] != TARGET_VALUE) ||
1162 data_in[i][j] != NC_FILL_INTERR;
1163
1164      if (nc_close(ncid)) ERR;
1165
1166      /* Open the file and check the same stuff. */
1167      if (nc_open(FILE_NAMENC_NOWRITE, &ncid)) ERR;
1168
1169      /* Get the data, and check the values. */
1170      if (nc_get_var_int(ncid, 0, &data_in[0][0])) ERR;
1171      for (i = 0; i < D1_TARGETi++)
1172  for (j = 0; j < D2_LENj++)
1173     if ((i == D1_TARGET && j == D2_TARGET && data_in[i][j] != TARGET_VALUE) ||
1174 data_in[i][j] != NC_FILL_INTERR;
1175
1176      if (nc_close(ncid)) ERR;
1177   }
1178
1179   SUMMARIZE_ERR;
1180   printf("*** testing lots of variables...");
1181#define DIM_A_NAME "x"
1182#define DIM_A_LEN 10
1183#define NUM_VARS 2000
1184#define MAX_VARNAME 10
1185   {
1186      /* This simple test failed on HDF5 1.7.58, but passes just fine
1187       * on 1.8.0 alpha5... */
1188      int nciddimids[1], i;
1189      char varname[MAX_VARNAME];
1190      int varids[NUM_VARS];
1191
1192      /* Create a file with three dimensions. */
1193      if (nc_create(FILE_NAMENC_NETCDF4, &ncid)) ERR;
1194      if (nc_def_dim(ncidDIM_A_NAMEDIM_A_LEN, &dimids[0])) ERR;
1195
1196      /* Create a large number of variables. */
1197      for (i = 0; i < NUM_VARSi++)
1198      {
1199  sprintf(varname, "a_%d", i);
1200  if (nc_def_var(ncidvarnameNC_FLOAT, 1, dimids, &varids[i])) {
1201     ERR;
1202     break;
1203  }
1204      }
1205      if (nc_close(ncid)) ERR;
1206   }
1207   SUMMARIZE_ERR;
1208
1209#define NC3_CLASSIC_FILE "tst_pres_temp_4D_classic.nc"
1210#define NC3_64BIT_OFFSET_FILE "tst_pres_temp_4D_64bit_offset.nc"
1211#define NC3_NETCDF4_FILE "tst_pres_temp_4D_netcdf4.nc"
1212#define NC3_NETCDF4_CLASSIC_FILE "tst_pres_temp_4D_netcdf4_classic.nc"
1213
1214   printf("*** testing 4D example file in classic format...");
1215   if (create_4D_example(NC3_CLASSIC_FILENC_CLOBBER)) ERR;
1216   if (check_4D_example(NC3_CLASSIC_FILENC_FORMAT_CLASSIC)) ERR;
1217   SUMMARIZE_ERR;
1218
1219   printf("*** testing 4D example file in 64-bit offset format...");
1220   if (create_4D_example(NC3_64BIT_OFFSET_FILENC_CLOBBER|NC_64BIT_OFFSET)) ERR;
1221   if (check_4D_example(NC3_64BIT_OFFSET_FILENC_FORMAT_64BIT_OFFSET)) ERR;
1222   SUMMARIZE_ERR;
1223
1224   printf("*** testing 4D example file in netCDF-4/HDF5 format...");
1225   if (create_4D_example(NC3_NETCDF4_FILENC_CLOBBER|NC_NETCDF4)) ERR;
1226   if (check_4D_example(NC3_NETCDF4_FILENC_FORMAT_NETCDF4)) ERR;
1227   SUMMARIZE_ERR;
1228
1229   printf("*** testing 4D example file in netCDF-4/HDF5 format with classic model rules...");
1230   if (create_4D_example(NC3_NETCDF4_CLASSIC_FILENC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL)) ERR;
1231   if (check_4D_example(NC3_NETCDF4_CLASSIC_FILENC_FORMAT_NETCDF4_CLASSIC)) ERR;
1232   SUMMARIZE_ERR;
1233
1234   FINAL_RESULTS;
1235}


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