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 Ed Hartnett, Ward Fisher
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
72 int
create_4D_example(char * file_name,int cmode)73 create_4D_example(char *file_name, int cmode)
74 {
75 /* IDs for the netCDF file, dimensions, and variables. */
76 int ncid, lon_dimid, lat_dimid, lvl_dimid, rec_dimid;
77 int lat_varid, lon_varid, pres_varid, temp_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
85 only need enough space to hold one timestep of data; one
86 record. */
87 float pres_out[NLVL][NLAT][NLON];
88 float temp_out[NLVL][NLAT][NLON];
89
90 /* These program variables hold the latitudes and longitudes. */
91 float lats[NLAT], lons[NLON];
92
93 /* Loop indexes. */
94 int lvl, lat, lon, rec, i = 0;
95
96 /* Create some pretend data. If this wasn't an example program, we
97 * would have some real data to write, for example, model
98 * output. */
99 for (lat = 0; lat < NLAT; lat++)
100 lats[lat] = START_LAT + 5.*lat;
101 for (lon = 0; lon < NLON; lon++)
102 lons[lon] = START_LON + 5.*lon;
103
104 for (lvl = 0; lvl < NLVL; lvl++)
105 for (lat = 0; lat < NLAT; lat++)
106 for (lon = 0; lon < NLON; lon++)
107 {
108 pres_out[lvl][lat][lon] = SAMPLE_PRESSURE + i;
109 temp_out[lvl][lat][lon] = SAMPLE_TEMP + i++;
110 }
111
112 /* Create the file. */
113 if (nc_create(file_name, cmode, &ncid)) ERR;
114
115 /* Define the dimensions. The record dimension is defined to have
116 * unlimited length - it can grow as needed. In this example it is
117 * the time dimension.*/
118 if (nc_def_dim(ncid, LVL_NAME, NLVL, &lvl_dimid)) ERR;
119 if (nc_def_dim(ncid, LAT_NAME, NLAT, &lat_dimid)) ERR;
120 if (nc_def_dim(ncid, LON_NAME, NLON, &lon_dimid)) ERR;
121 if (nc_def_dim(ncid, REC_NAME, NC_UNLIMITED, &rec_dimid)) ERR;
122
123 /* Define the coordinate variables. We will only define coordinate
124 variables for lat and lon. Ordinarily we would need to provide
125 an array of dimension IDs for each variable's dimensions, but
126 since coordinate variables only have one dimension, we can
127 simply provide the address of that dimension ID (&lat_dimid) and
128 similarly for (&lon_dimid). */
129 if (nc_def_var(ncid, LAT_NAME, NC_FLOAT, 1, &lat_dimid,
130 &lat_varid)) ERR;
131 if (nc_def_var(ncid, LON_NAME, NC_FLOAT, 1, &lon_dimid,
132 &lon_varid)) ERR;
133
134 /* Assign units attributes to coordinate variables. */
135 if (nc_put_att_text(ncid, lat_varid, UNITS,
136 strlen(DEGREES_NORTH), DEGREES_NORTH)) ERR;
137 if (nc_put_att_text(ncid, lon_varid, UNITS,
138 strlen(DEGREES_EAST), DEGREES_EAST)) ERR;
139
140 /* The dimids array is used to pass the dimids of the dimensions of
141 the netCDF variables. Both of the netCDF variables we are
142 creating share the same four dimensions. In C, the
143 unlimited dimension must come first on the list of dimids. */
144 dimids[0] = rec_dimid;
145 dimids[1] = lvl_dimid;
146 dimids[2] = lat_dimid;
147 dimids[3] = lon_dimid;
148
149 /* Define the netCDF variables for the pressure and temperature
150 * data. */
151 if (nc_def_var(ncid, PRES_NAME, NC_FLOAT, NDIMS_EX,
152 dimids, &pres_varid)) ERR;
153 if (nc_def_var(ncid, TEMP_NAME, NC_FLOAT, NDIMS_EX,
154 dimids, &temp_varid)) ERR;
155
156 /* Assign units attributes to the netCDF variables. */
157 if (nc_put_att_text(ncid, pres_varid, UNITS,
158 strlen(PRES_UNITS), PRES_UNITS)) ERR;
159 if (nc_put_att_text(ncid, temp_varid, UNITS,
160 strlen(TEMP_UNITS), TEMP_UNITS)) ERR;
161
162 /* End define mode. */
163 if (nc_enddef(ncid)) ERR;
164
165 /* Write the coordinate variable data. This will put the latitudes
166 and longitudes of our data grid into the netCDF file. */
167 if (nc_put_var_float(ncid, lat_varid, &lats[0])) ERR;
168 if (nc_put_var_float(ncid, lon_varid, &lons[0])) ERR;
169
170 /* These settings tell netcdf to write one timestep of data. (The
171 setting of start[0] inside the loop below tells netCDF which
172 timestep to write.) */
173 count[0] = 1;
174 count[1] = NLVL;
175 count[2] = NLAT;
176 count[3] = NLON;
177 start[1] = 0;
178 start[2] = 0;
179 start[3] = 0;
180
181 /* Write the pretend data. This will write our surface pressure and
182 surface temperature data. The arrays only hold one timestep worth
183 of data. We will just rewrite the same data for each timestep. In
184 a real application, the data would change between timesteps. */
185 for (rec = 0; rec < NREC; rec++)
186 {
187 start[0] = rec;
188
189 /* This won't work due to bad id. */
190 if (nc_put_vara_float(ncid + MILLION, pres_varid, start, count,
191 &pres_out[0][0][0]) != NC_EBADID) ERR;
192
193 /* Now write the data. */
194 if (nc_put_vara_float(ncid, pres_varid, start, count,
195 &pres_out[0][0][0])) ERR;
196 if (nc_put_vara_float(ncid, temp_varid, start, count,
197 &temp_out[0][0][0])) ERR;
198 }
199
200 /* Close the file. */
201 if (nc_close(ncid)) ERR;
202
203 return err;
204 }
205
206 int
check_4D_example(char * file_name,int expected_format)207 check_4D_example(char *file_name, int expected_format)
208 {
209 int ncid;
210 int format, ndims_in, nvars_in, natts_in;
211 int dimid[NDIMS_EX];
212 int varid[NVARS_EX];
213 char dim_name_in[NDIMS_EX][NC_MAX_NAME];
214 char var_name_in[NVARS_EX][NC_MAX_NAME];
215 char name_in[NC_MAX_NAME + 1];
216 char units_in[NC_MAX_NAME + 1];
217 nc_type xtype_in;
218 size_t len_in;
219 int i;
220
221 if (nc_open(file_name, 0, &ncid)) ERR;
222
223 /* Count stuff. */
224 if (nc_inq_format(ncid, &format)) ERR;
225 if (nc_inq_ndims(ncid, &ndims_in)) ERR;
226 if (ndims_in != NDIMS_EX) ERR;
227 if (nc_inq_nvars(ncid, &nvars_in)) ERR;
228 if (nvars_in != NVARS_EX) ERR;
229 if (nc_inq_natts(ncid, &natts_in)) ERR;
230 if (natts_in != 0) ERR;
231 if (format != expected_format) ERR;
232
233 /* Check dimensions. */
234 ndims_in = 0;
235 if (nc_inq_dimids(ncid, &ndims_in, dimid, 0)) ERR;
236 if (ndims_in != NDIMS_EX) ERR;
237 for (i = 0; i < NDIMS_EX; i++)
238 {
239 if (dimid[i] != i) ERR;
240 if (nc_inq_dimname(ncid, i, dim_name_in[i])) ERR;
241 }
242 if (strcmp(dim_name_in[0], LVL_NAME) || strcmp(dim_name_in[1], LAT_NAME) ||
243 strcmp(dim_name_in[2], LON_NAME) || strcmp(dim_name_in[3], REC_NAME)) ERR;
244
245 /* Check variables. */
246 nvars_in = 0;
247 if (nc_inq_varids(ncid, &nvars_in, varid)) ERR;
248 if (nvars_in != NVARS_EX) ERR;
249 for (i = 0; i < NVARS_EX; i++)
250 {
251 if (varid[i] != i) ERR;
252 if (nc_inq_varname(ncid, i, var_name_in[i])) ERR;
253 }
254 if (strcmp(var_name_in[0], LAT_NAME) || strcmp(var_name_in[1], LON_NAME) ||
255 strcmp(var_name_in[2], PRES_NAME) || strcmp(var_name_in[3], TEMP_NAME)) ERR;
256
257 if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR;
258 if (strcmp(name_in, LAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
259 dimid[0] != 1 || natts_in != 1) ERR;
260 if (nc_inq_var(ncid, 1, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR;
261 if (strcmp(name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
262 dimid[0] != 2 || natts_in != 1) ERR;
263 if (nc_inq_var(ncid, 2, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR;
264 if (strcmp(name_in, PRES_NAME) || xtype_in != NC_FLOAT || ndims_in != 4 ||
265 dimid[0] != 3 || dimid[1] != 0 || dimid[2] != 1 || dimid[3] != 2 ||
266 natts_in != 1) ERR;
267 if (nc_inq_var(ncid, 3, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR;
268 if (strcmp(name_in, TEMP_NAME) || xtype_in != NC_FLOAT || ndims_in != 4 ||
269 dimid[0] != 3 || dimid[1] != 0 || dimid[2] != 1 || dimid[3] != 2 ||
270 natts_in != 1) ERR;
271
272 /* Check variable atts. */
273 if (nc_inq_att(ncid, 0, UNITS, &xtype_in, &len_in)) ERR;
274 if (xtype_in != NC_CHAR || len_in != strlen(DEGREES_NORTH)) ERR;
275 if (nc_get_att_text(ncid, 0, UNITS, units_in)) ERR;
276 if (strncmp(units_in, DEGREES_NORTH, strlen(DEGREES_NORTH))) ERR;
277
278 if (nc_inq_att(ncid, 1, UNITS, &xtype_in, &len_in)) ERR;
279 if (xtype_in != NC_CHAR || len_in != strlen(DEGREES_EAST)) ERR;
280 if (nc_get_att_text(ncid, 1, UNITS, units_in)) ERR;
281 if (strncmp(units_in, DEGREES_EAST, strlen(DEGREES_EAST))) ERR;
282
283 if (nc_inq_att(ncid, 2, UNITS, &xtype_in, &len_in)) ERR;
284 if (xtype_in != NC_CHAR || len_in != strlen(PRES_UNITS)) ERR;
285 if (nc_get_att_text(ncid, 2, UNITS, units_in)) ERR;
286 if (strncmp(units_in, PRES_UNITS, strlen(PRES_UNITS))) ERR;
287
288 if (nc_inq_att(ncid, 3, UNITS, &xtype_in, &len_in)) ERR;
289 if (xtype_in != NC_CHAR || len_in != strlen(TEMP_UNITS)) ERR;
290 if (nc_get_att_text(ncid, 3, UNITS, units_in)) ERR;
291 if (strncmp(units_in, TEMP_UNITS, strlen(TEMP_UNITS))) ERR;
292
293 if (nc_close(ncid)) ERR;
294 return err;
295 }
296
297 int
main(int argc,char ** argv)298 main(int argc, char **argv)
299 {
300 int ncid, dimids[3];
301 int char_varid, byte_varid, ubyte_varid, short_varid, int_varid, float_varid, double_varid;
302 int ushort_varid, uint_varid, int64_varid, uint64_varid;
303 int i, j;
304
305 unsigned char ubyte_out[DIM1_LEN][DIM2_LEN] = {{1, 128, 255},{1, 128, 255}};
306 signed char byte_in[DIM1_LEN][DIM2_LEN], byte_out[DIM1_LEN][DIM2_LEN] = {{-127, 1, 127},{-127, 1, 127}};
307 unsigned short ushort_out[DIM1_LEN][DIM2_LEN] = {{110, 128, 255},{110, 128, 255}};
308 short short_in[DIM1_LEN][DIM2_LEN], short_out[DIM1_LEN][DIM2_LEN] = {{-110, -128, 255},{-110, -128, 255}};
309 int int_in[DIM1_LEN][DIM2_LEN], int_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
310 float float_in[DIM1_LEN][DIM2_LEN], float_out[DIM1_LEN][DIM2_LEN] = {{-.1, 9999.99, 100.001},{-.1, 9999.99, 100.001}};
311 double double_in[DIM1_LEN][DIM2_LEN], double_out[DIM1_LEN][DIM2_LEN] = {{0.02, .1128, 1090.1},{0.02, .1128, 1090.1}};
312 unsigned int uint_in[DIM1_LEN][DIM2_LEN], uint_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
313 long long int64_in[DIM1_LEN][DIM2_LEN], int64_out[DIM1_LEN][DIM2_LEN] = {{-111, 777, 100},{-111, 777, 100}};
314 unsigned long long uint64_in[DIM1_LEN][DIM2_LEN];
315 unsigned long long uint64_out[DIM1_LEN][DIM2_LEN] = {{0, 10101, 9999999},{0, 10101, 9999999}};
316 char char_out[DIM1_LEN][DIM2_LEN][DIM3_LEN] = {{"lalala", "lololo", "lelele"}, {"lalala", "lololo", "lelele"}};
317
318 printf("\n*** Testing netcdf-4 variable functions.\n");
319
320 printf("*** testing netcdf-4 varids inq on netcdf-3 file...");
321 {
322 int nvars_in, varids_in[2];
323
324 /* Create a netcdf-3 file with one dim and two vars. */
325 if (nc_create(FILE_NAME, 0, &ncid)) ERR;
326 if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
327 if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
328 if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
329 if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
330 if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
331 if (nc_close(ncid)) ERR;
332
333 /* Open the file and make sure nc_inq_varids yields correct
334 * result. */
335 if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
336 if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
337 if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR;
338 if (nc_close(ncid)) ERR;
339 }
340
341 SUMMARIZE_ERR;
342 printf("*** testing simple variables...");
343
344 {
345 int bad_dimids[3] = {1, 2, 5}; /* "Three sir!" */
346
347 /* Create a file with a variable of each type. */
348 if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
349 if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
350 if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
351 if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
352
353 /* These attempts will fail due to bad parameters. */
354 if (nc_def_var(ncid + MILLION, VAR_BYTE_NAME, NC_BYTE, 2, dimids,
355 &byte_varid) != NC_EBADID) ERR;
356 if (nc_def_var(ncid + TEST_VAL_42, VAR_BYTE_NAME, NC_BYTE, 2, dimids,
357 &byte_varid) != NC_EBADID) ERR;
358 if (nc_def_var(ncid, BAD_NAME, NC_BYTE, 2, dimids,
359 &byte_varid) != NC_EBADNAME) ERR;
360 if (nc_def_var(ncid, VAR_BYTE_NAME, 0, 2, dimids,
361 &byte_varid) != NC_EBADTYPE) ERR;
362 if (nc_def_var(ncid, VAR_BYTE_NAME, TEST_VAL_42, 2, dimids,
363 &byte_varid) != NC_EBADTYPE) ERR;
364 if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, -2, dimids,
365 &byte_varid) != NC_EINVAL) ERR;
366 if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, NULL,
367 &byte_varid) != NC_EINVAL) ERR;
368 if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 3, bad_dimids,
369 &byte_varid) != NC_EBADDIM) ERR;
370
371 /* Now create our variables. */
372 if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
373 if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
374 if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR;
375 if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR;
376 if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR;
377 if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR;
378 if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
379 if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR;
380 if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR;
381 if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR;
382 if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR;
383 if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR;
384 if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR;
385 if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR;
386 if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR;
387 if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR;
388 if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR;
389 if (nc_put_var_uchar(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR;
390 if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR;
391 if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR;
392 if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR;
393 if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR;
394 if (nc_close(ncid)) ERR;
395
396 /* Open the file and check metadata. */
397 {
398 nc_type xtype_in;
399 int ndims_in, dimids_in[10], natts_in, varid_in;
400 char name_in[NC_MAX_NAME+1];
401 size_t size_in;
402
403 if (nc_open(FILE_NAME, 0, &ncid)) ERR;
404 if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in,
405 &natts_in)) ERR;
406 if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE ||
407 ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
408 dimids_in[1] != dimids[1]) ERR;
409 if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR;
410 if (varid_in != 0) ERR;
411 if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR;
412 if (varid_in != 1) ERR;
413 if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR;
414 if (varid_in != 2) ERR;
415 if (nc_inq_varname(ncid, 0, name_in)) ERR;
416 if (strcmp(name_in, VAR_BYTE_NAME)) ERR;
417 if (nc_inq_varname(ncid, 1, name_in)) ERR;
418 if (strcmp(name_in, VAR_CHAR_NAME)) ERR;
419 if (nc_inq_varname(ncid, 2, name_in)) ERR;
420 if (strcmp(name_in, VAR_SHORT_NAME)) ERR;
421 if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
422 if (xtype_in != NC_BYTE) ERR;
423 if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
424 if (xtype_in != NC_CHAR) ERR;
425 if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
426 if (xtype_in != NC_SHORT) ERR;
427
428 /* Check inquire of atomic types */
429 if (nc_inq_type(ncid, NC_BYTE, name_in, &size_in)) ERR;
430 if (strcmp(name_in, "byte") || size_in != sizeof(char)) ERR;
431 if (nc_inq_type(ncid, NC_CHAR, name_in, &size_in)) ERR;
432 if (strcmp(name_in, "char") || size_in != sizeof(char)) ERR;
433 if (nc_inq_type(ncid, NC_SHORT, name_in, &size_in)) ERR;
434 if (strcmp(name_in, "short") || size_in != sizeof(short)) ERR;
435 if (nc_inq_type(ncid, NC_INT, name_in, &size_in)) ERR;
436 if (strcmp(name_in, "int") || size_in != sizeof(int)) ERR;
437 if (nc_inq_type(ncid, NC_FLOAT, name_in, &size_in)) ERR;
438 if (strcmp(name_in, "float") || size_in != sizeof(float)) ERR;
439 if (nc_inq_type(ncid, NC_DOUBLE, name_in, &size_in)) ERR;
440 if (strcmp(name_in, "double") || size_in != sizeof(double)) ERR;
441 if (nc_inq_type(ncid, NC_UBYTE, name_in, &size_in)) ERR;
442 if (strcmp(name_in, "ubyte") || size_in != sizeof(unsigned char)) ERR;
443 if (nc_inq_type(ncid, NC_USHORT, name_in, &size_in)) ERR;
444 if (strcmp(name_in, "ushort") || size_in != sizeof(unsigned short)) ERR;
445 if (nc_inq_type(ncid, NC_UINT, name_in, &size_in)) ERR;
446 if (strcmp(name_in, "uint") || size_in != sizeof(unsigned int)) ERR;
447 if (nc_inq_type(ncid, NC_INT64, name_in, &size_in)) ERR;
448 if (strcmp(name_in, "int64") || size_in != sizeof(long long)) ERR;
449 if (nc_inq_type(ncid, NC_UINT64, name_in, &size_in)) ERR;
450 if (strcmp(name_in, "uint64") || size_in != sizeof(unsigned long long)) ERR;
451 if (nc_inq_type(ncid, NC_STRING, name_in, &size_in)) ERR;
452 if (strcmp(name_in, "string") || size_in != sizeof(char *)) ERR;
453
454 if (nc_inq_typeid(ncid, "byte", &xtype_in)) ERR;
455 if (xtype_in != NC_BYTE) ERR;
456 if (nc_inq_typeid(ncid, "char", &xtype_in)) ERR;
457 if (xtype_in != NC_CHAR) ERR;
458 if (nc_inq_typeid(ncid, "short", &xtype_in)) ERR;
459 if (xtype_in != NC_SHORT) ERR;
460 if (nc_inq_typeid(ncid, "int", &xtype_in)) ERR;
461 if (xtype_in != NC_INT) ERR;
462 if (nc_inq_typeid(ncid, "float", &xtype_in)) ERR;
463 if (xtype_in != NC_FLOAT) ERR;
464 if (nc_inq_typeid(ncid, "double", &xtype_in)) ERR;
465 if (xtype_in != NC_DOUBLE) ERR;
466 if (nc_inq_typeid(ncid, "ubyte", &xtype_in)) ERR;
467 if (xtype_in != NC_UBYTE) ERR;
468 if (nc_inq_typeid(ncid, "ushort", &xtype_in)) ERR;
469 if (xtype_in != NC_USHORT) ERR;
470 if (nc_inq_typeid(ncid, "uint", &xtype_in)) ERR;
471 if (xtype_in != NC_UINT) ERR;
472 if (nc_inq_typeid(ncid, "int64", &xtype_in)) ERR;
473 if (xtype_in != NC_INT64) ERR;
474 if (nc_inq_typeid(ncid, "uint64", &xtype_in)) ERR;
475 if (xtype_in != NC_UINT64) ERR;
476 if (nc_inq_typeid(ncid, "string", &xtype_in)) ERR;
477 if (xtype_in != NC_STRING) ERR;
478
479 if (nc_close(ncid)) ERR;
480 }
481
482 /* Open the file and check data. */
483 if (nc_open(FILE_NAME, 0, &ncid)) ERR;
484 if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
485 for (i = 0; i < DIM1_LEN; i++)
486 for (j = 0; j < DIM2_LEN; j++)
487 if (byte_in[i][j] != byte_out[i][j]) ERR;
488 if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR;
489 for (i = 0; i < DIM1_LEN; i++)
490 for (j = 0; j < DIM2_LEN; j++)
491 if (short_in[i][j] != short_out[i][j]) ERR;
492 if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR;
493 for (i = 0; i < DIM1_LEN; i++)
494 for (j = 0; j < DIM2_LEN; j++)
495 if (int_in[i][j] != int_out[i][j]) ERR;
496 if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR;
497 for (i = 0; i < DIM1_LEN; i++)
498 for (j = 0; j < DIM2_LEN; j++)
499 if (float_in[i][j] != float_out[i][j]) ERR;
500 if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
501 for (i = 0; i < DIM1_LEN; i++)
502 for (j = 0; j < DIM2_LEN; j++)
503 if (double_in[i][j] != double_out[i][j]) ERR;
504 if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
505 for (i = 0; i < DIM1_LEN; i++)
506 for (j = 0; j < DIM2_LEN; j++)
507 if (double_in[i][j] != double_out[i][j]) ERR;
508 if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
509 for (i = 0; i < DIM1_LEN; i++)
510 for (j = 0; j < DIM2_LEN; j++)
511 if (double_in[i][j] != double_out[i][j]) ERR;
512 if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR;
513 for (i = 0; i < DIM1_LEN; i++)
514 for (j = 0; j < DIM2_LEN; j++)
515 if (uint_in[i][j] != uint_out[i][j]) ERR;
516 if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR;
517 for (i = 0; i < DIM1_LEN; i++)
518 for (j = 0; j < DIM2_LEN; j++)
519 if (int64_in[i][j] != int64_out[i][j]) ERR;
520 if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR;
521 for (i = 0; i < DIM1_LEN; i++)
522 for (j = 0; j < DIM2_LEN; j++)
523 if (uint64_in[i][j] != uint64_out[i][j]) ERR;
524 if (nc_close(ncid)) ERR;
525
526 /* Open the file and read everything as double. */
527 if (nc_open(FILE_NAME, 0, &ncid)) ERR;
528 if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR;
529 for (i = 0; i < DIM1_LEN; i++)
530 for (j = 0; j < DIM2_LEN; j++)
531 if (double_in[i][j] != (double)byte_out[i][j]) ERR;
532 if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR;
533 for (i = 0; i < DIM1_LEN; i++)
534 for (j = 0; j < DIM2_LEN; j++)
535 if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
536 if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR;
537 for (i = 0; i < DIM1_LEN; i++)
538 for (j = 0; j < DIM2_LEN; j++)
539 if (double_in[i][j] != (double)short_out[i][j]) ERR;
540 if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR;
541 for (i = 0; i < DIM1_LEN; i++)
542 for (j = 0; j < DIM2_LEN; j++)
543 if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
544 if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR;
545 for (i = 0; i < DIM1_LEN; i++)
546 for (j = 0; j < DIM2_LEN; j++)
547 if (double_in[i][j] != (double)int_out[i][j]) ERR;
548 if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR;
549 for (i = 0; i < DIM1_LEN; i++)
550 for (j = 0; j < DIM2_LEN; j++)
551 if (double_in[i][j] != (double)uint_out[i][j]) ERR;
552 if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR;
553 for (i = 0; i < DIM1_LEN; i++)
554 for (j = 0; j < DIM2_LEN; j++)
555 if (double_in[i][j] != (double)float_out[i][j]) ERR;
556 if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR;
557 for (i = 0; i < DIM1_LEN; i++)
558 for (j = 0; j < DIM2_LEN; j++)
559 if (double_in[i][j] != (double)int64_out[i][j]) ERR;
560 if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR;
561 for (i = 0; i < DIM1_LEN; i++)
562 for (j = 0; j < DIM2_LEN; j++)
563 if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
564 if (nc_close(ncid)) ERR;
565
566 /* Open the file and read everything as NC_BYTE. */
567 if (nc_open(FILE_NAME, 0, &ncid)) ERR;
568 if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
569 for (i = 0; i < DIM1_LEN; i++)
570 for (j = 0; j < DIM2_LEN; j++)
571 if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
572 if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
573 for (i = 0; i < DIM1_LEN; i++)
574 for (j = 0; j < DIM2_LEN; j++)
575 if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
576 if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
577 for (i = 0; i < DIM1_LEN; i++)
578 for (j = 0; j < DIM2_LEN; j++)
579 if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
580 if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
581 for (i = 0; i < DIM1_LEN; i++)
582 for (j = 0; j < DIM2_LEN; j++)
583 if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
584 if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
585 for (i = 0; i < DIM1_LEN; i++)
586 for (j = 0; j < DIM2_LEN; j++)
587 if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
588 if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
589 for (i = 0; i < DIM1_LEN; i++)
590 for (j = 0; j < DIM2_LEN; j++)
591 if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
592 if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
593 for (i = 0; i < DIM1_LEN; i++)
594 for (j = 0; j < DIM2_LEN; j++)
595 if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
596 if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
597 for (i = 0; i < DIM1_LEN; i++)
598 for (j = 0; j < DIM2_LEN; j++)
599 if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
600 if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
601 for (i = 0; i < DIM1_LEN; i++)
602 for (j = 0; j < DIM2_LEN; j++)
603 if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
604 if (nc_close(ncid)) ERR;
605 }
606 SUMMARIZE_ERR;
607
608 #define DEFLATE_LEVEL_4 4
609
610 printf("*** testing simple variables with deflation...");
611 {
612 /* Create a file with a variable of each type. */
613 if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
614 if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
615 if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
616 if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
617 if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
618 if (nc_def_var_deflate(ncid, byte_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
619 if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
620 if (nc_def_var_deflate(ncid, byte_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
621 if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR;
622 if (nc_def_var_deflate(ncid, short_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
623 if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR;
624 if (nc_def_var_deflate(ncid, int_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
625 if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR;
626 if (nc_def_var_deflate(ncid, float_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
627 if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR;
628 if (nc_def_var_deflate(ncid, double_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
629 if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
630 if (nc_def_var_deflate(ncid, ubyte_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
631 if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR;
632 if (nc_def_var_deflate(ncid, ushort_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
633 if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR;
634 if (nc_def_var_deflate(ncid, uint_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
635 if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR;
636 if (nc_def_var_deflate(ncid, int64_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
637 if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR;
638 if (nc_def_var_deflate(ncid, uint64_varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL_4)) ERR;
639
640 if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR_RET;
641 if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR;
642 if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR;
643 if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR;
644 if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR;
645 if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR;
646 if (nc_put_var_uchar(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR;
647 if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR;
648 if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR;
649 if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR;
650 if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR;
651 if (nc_close(ncid)) ERR;
652
653 /* Open the file and check metadata. */
654 {
655 nc_type xtype_in;
656 int ndims_in, dimids_in[10], natts_in, varid_in;
657 char name_in[NC_MAX_NAME+1];
658
659 if (nc_open(FILE_NAME, 0, &ncid)) ERR;
660 if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in,
661 &natts_in)) ERR;
662 if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE ||
663 ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
664 dimids_in[1] != dimids[1]) ERR;
665 if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR;
666 if (varid_in != 0) ERR;
667 if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR;
668 if (varid_in != 1) ERR;
669 if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR;
670 if (varid_in != 2) ERR;
671 if (nc_inq_varname(ncid, 0, name_in)) ERR;
672 if (strcmp(name_in, VAR_BYTE_NAME)) ERR;
673 if (nc_inq_varname(ncid, 1, name_in)) ERR;
674 if (strcmp(name_in, VAR_CHAR_NAME)) ERR;
675 if (nc_inq_varname(ncid, 2, name_in)) ERR;
676 if (strcmp(name_in, VAR_SHORT_NAME)) ERR;
677 if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
678 if (xtype_in != NC_BYTE) ERR;
679 if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
680 if (xtype_in != NC_CHAR) ERR;
681 if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
682 if (xtype_in != NC_SHORT) ERR;
683 if (nc_close(ncid)) ERR;
684 }
685
686 /* Open the file and check data. */
687 if (nc_open(FILE_NAME, 0, &ncid)) ERR;
688 if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
689 for (i = 0; i < DIM1_LEN; i++)
690 for (j = 0; j < DIM2_LEN; j++)
691 if (byte_in[i][j] != byte_out[i][j]) ERR;
692 if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR;
693 for (i = 0; i < DIM1_LEN; i++)
694 for (j = 0; j < DIM2_LEN; j++)
695 if (short_in[i][j] != short_out[i][j]) ERR;
696 if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR;
697 for (i = 0; i < DIM1_LEN; i++)
698 for (j = 0; j < DIM2_LEN; j++)
699 if (int_in[i][j] != int_out[i][j]) ERR;
700 if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR;
701 for (i = 0; i < DIM1_LEN; i++)
702 for (j = 0; j < DIM2_LEN; j++)
703 if (float_in[i][j] != float_out[i][j]) ERR;
704 if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
705 for (i = 0; i < DIM1_LEN; i++)
706 for (j = 0; j < DIM2_LEN; j++)
707 if (double_in[i][j] != double_out[i][j]) ERR;
708 if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
709 for (i = 0; i < DIM1_LEN; i++)
710 for (j = 0; j < DIM2_LEN; j++)
711 if (double_in[i][j] != double_out[i][j]) ERR;
712 if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
713 for (i = 0; i < DIM1_LEN; i++)
714 for (j = 0; j < DIM2_LEN; j++)
715 if (double_in[i][j] != double_out[i][j]) ERR;
716 if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR;
717 for (i = 0; i < DIM1_LEN; i++)
718 for (j = 0; j < DIM2_LEN; j++)
719 if (uint_in[i][j] != uint_out[i][j]) ERR;
720 if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR;
721 for (i = 0; i < DIM1_LEN; i++)
722 for (j = 0; j < DIM2_LEN; j++)
723 if (int64_in[i][j] != int64_out[i][j]) ERR;
724 if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR;
725 for (i = 0; i < DIM1_LEN; i++)
726 for (j = 0; j < DIM2_LEN; j++)
727 if (uint64_in[i][j] != uint64_out[i][j]) ERR;
728 if (nc_close(ncid)) ERR;
729
730 /* Open the file and read everything as double. */
731 if (nc_open(FILE_NAME, 0, &ncid)) ERR;
732 if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR;
733 for (i = 0; i < DIM1_LEN; i++)
734 for (j = 0; j < DIM2_LEN; j++)
735 if (double_in[i][j] != (double)byte_out[i][j]) ERR;
736 if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR;
737 for (i = 0; i < DIM1_LEN; i++)
738 for (j = 0; j < DIM2_LEN; j++)
739 if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
740 if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR;
741 for (i = 0; i < DIM1_LEN; i++)
742 for (j = 0; j < DIM2_LEN; j++)
743 if (double_in[i][j] != (double)short_out[i][j]) ERR;
744 if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR;
745 for (i = 0; i < DIM1_LEN; i++)
746 for (j = 0; j < DIM2_LEN; j++)
747 if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
748 if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR;
749 for (i = 0; i < DIM1_LEN; i++)
750 for (j = 0; j < DIM2_LEN; j++)
751 if (double_in[i][j] != (double)int_out[i][j]) ERR;
752 if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR;
753 for (i = 0; i < DIM1_LEN; i++)
754 for (j = 0; j < DIM2_LEN; j++)
755 if (double_in[i][j] != (double)uint_out[i][j]) ERR;
756 if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR;
757 for (i = 0; i < DIM1_LEN; i++)
758 for (j = 0; j < DIM2_LEN; j++)
759 if (double_in[i][j] != (double)float_out[i][j]) ERR;
760 if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR;
761 for (i = 0; i < DIM1_LEN; i++)
762 for (j = 0; j < DIM2_LEN; j++)
763 if (double_in[i][j] != (double)int64_out[i][j]) ERR;
764 if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR;
765 for (i = 0; i < DIM1_LEN; i++)
766 for (j = 0; j < DIM2_LEN; j++)
767 if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
768 if (nc_close(ncid)) ERR;
769
770 /* Open the file and read everything as NC_BYTE. */
771 if (nc_open(FILE_NAME, 0, &ncid)) ERR;
772 if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
773 for (i = 0; i < DIM1_LEN; i++)
774 for (j = 0; j < DIM2_LEN; j++)
775 if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
776 if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
777 for (i = 0; i < DIM1_LEN; i++)
778 for (j = 0; j < DIM2_LEN; j++)
779 if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
780 if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
781 for (i = 0; i < DIM1_LEN; i++)
782 for (j = 0; j < DIM2_LEN; j++)
783 if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
784 if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
785 for (i = 0; i < DIM1_LEN; i++)
786 for (j = 0; j < DIM2_LEN; j++)
787 if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
788 if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
789 for (i = 0; i < DIM1_LEN; i++)
790 for (j = 0; j < DIM2_LEN; j++)
791 if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
792 if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
793 for (i = 0; i < DIM1_LEN; i++)
794 for (j = 0; j < DIM2_LEN; j++)
795 if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
796 if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
797 for (i = 0; i < DIM1_LEN; i++)
798 for (j = 0; j < DIM2_LEN; j++)
799 if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
800 if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
801 for (i = 0; i < DIM1_LEN; i++)
802 for (j = 0; j < DIM2_LEN; j++)
803 if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
804 if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
805 for (i = 0; i < DIM1_LEN; i++)
806 for (j = 0; j < DIM2_LEN; j++)
807 if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
808 if (nc_close(ncid)) ERR;
809
810 }
811 SUMMARIZE_ERR;
812
813 #define NDIMS4 1
814 #define NVARS4 1
815 #define DIM4_NAME "treaty_of_paris_1783"
816 #define DIM4_LEN 5
817 #define VAR_NAME4 "John_Adams"
818 #define DEFLATE_LEVEL 6
819
820 printf("*** testing netcdf-4 simple variable define...");
821 {
822 int dimids[NDIMS4], dimids_in[NDIMS4];
823 int varid, varids_in[NVARS4];
824 int ndims, nvars, natts, unlimdimid;
825 nc_type xtype_in;
826 char name_in[NC_MAX_NAME + 1];
827 int shuffle_in, deflate_in, deflate_level;
828
829 /* Create a netcdf-4 file with one dim and one var. */
830 if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
831 if (nc_def_dim(ncid, DIM4_NAME, DIM4_LEN, &dimids[0])) ERR;
832 if (dimids[0] != 0) ERR;
833 if (nc_def_var(ncid, VAR_NAME4, NC_INT64, NDIMS4, dimids, &varid)) ERR;
834 if (nc_def_var_deflate(ncid, varid, NC_NOSHUFFLE, 1, DEFLATE_LEVEL)) ERR;
835 if (varid != 0) ERR;
836
837 /* Check stuff. */
838 if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
839 if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
840 unlimdimid != -1) ERR;
841 if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
842 if (nvars != NVARS4) ERR;
843 if (varids_in[0] != 0) ERR;
844 if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
845 dimids_in, &natts)) ERR;
846 if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 ||
847 ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
848 if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
849 &deflate_level)) ERR;
850 if (shuffle_in != NC_NOSHUFFLE ||!deflate_in ||
851 deflate_level != DEFLATE_LEVEL) ERR;
852
853 if (nc_close(ncid)) ERR;
854
855 /* Open the file and check the same stuff. */
856 if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
857
858 /* Can't define a var! */
859 if (nc_def_var(ncid, "this_wont_work", NC_INT, NDIMS4, dimids, &varid)
860 != NC_EPERM) ERR;
861
862 if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
863 if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
864 unlimdimid != -1) ERR;
865 if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
866 if (nvars != NVARS4) ERR;
867 if (varids_in[0] != 0) ERR;
868 if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
869 dimids_in, &natts)) ERR;
870 if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 ||
871 ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
872 if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
873 &deflate_level)) ERR;
874 if (shuffle_in != NC_NOSHUFFLE ||!deflate_in ||
875 deflate_level != DEFLATE_LEVEL) ERR;
876
877 if (nc_close(ncid)) ERR;
878 }
879
880 SUMMARIZE_ERR;
881
882 #define NDIMS5 1
883 #define NVARS5 5
884 #define DIM5_NAME "treaty_of_paris_1783"
885 #define DIM5_LEN 5
886
887 printf("*** testing netcdf-4 less simple variable define...");
888 {
889 int dimids[NDIMS5], dimids_in[NDIMS5];
890 int varid[NVARS5], varids_in[NVARS5];
891 int ndims, nvars, natts, unlimdimid;
892 nc_type xtype_in;
893 char name_in[NC_MAX_NAME + 1];
894 char var_name[NVARS5][NC_MAX_NAME + 1] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
895 "Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
896 "Charles_F_Ritchel"};
897 int shuffle_in, deflate_in, deflate_level_in;
898 int deflate_level[NVARS5];
899 int i;
900
901 /* Set up options for this var. */
902 for (i = 0; i < NVARS5; i++)
903 deflate_level[i] = i;
904
905 /* Create a netcdf-4 file with one dim and two vars. */
906 if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
907 if (nc_def_dim(ncid, DIM5_NAME, DIM5_LEN, &dimids[0])) ERR;
908 if (dimids[0] != 0) ERR;
909 for (i = 0; i < NVARS5; i++)
910 {
911 if (nc_def_var(ncid, var_name[i], NC_INT64, NDIMS5, dimids,
912 &varid[i])) ERR;
913 if (varid[i] != i) ERR;
914 if (nc_def_var_deflate(ncid, varid[i], NC_SHUFFLE, 1, deflate_level[i])) ERR;
915 }
916
917 /* Check stuff. */
918 if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
919 if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
920 unlimdimid != -1) ERR;
921 if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
922 if (nvars != NVARS5) ERR;
923 for (i = 0; i < NVARS5; i++)
924 {
925 if (varids_in[i] != i) ERR;
926 if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
927 dimids_in, &natts)) ERR;
928 if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 ||
929 ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
930 if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
931 &deflate_level_in)) ERR;
932 if (shuffle_in != NC_SHUFFLE || !deflate_in ||
933 deflate_level_in != deflate_level[i]) ERR;
934 }
935
936 if (nc_close(ncid)) ERR;
937
938 /* Open the file and check the same stuff. */
939 if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
940
941 if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
942 if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
943 unlimdimid != -1) ERR;
944 if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
945 if (nvars != NVARS5) ERR;
946 for (i = 0; i < NVARS5; i++)
947 {
948 if (varids_in[i] != i) ERR;
949 if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
950 dimids_in, &natts)) ERR;
951 if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 ||
952 ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
953 if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
954 &deflate_level_in)) ERR;
955 if (shuffle_in != NC_SHUFFLE || !deflate_in ||
956 deflate_level_in != deflate_level[i]) ERR;
957 }
958
959 if (nc_close(ncid)) ERR;
960 }
961
962 SUMMARIZE_ERR;
963
964 #define NVARS 5
965 #define NDIMS 1
966 #define DIM6_NAME "airship_cross_sectional_area"
967 #define DIM6_LEN 100
968 #define TEN_K_M2 10000.0
969 #define INCREMENT 1000.0
970
971 printf("*** testing more complex netcdf-4 variable defines...");
972 {
973 int dimids[NDIMS], dimids_in[NDIMS];
974 int varid[NVARS], varids_in[NVARS];
975 int ndims, nvars, natts, unlimdimid;
976 char var_name[NVARS][50] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
977 "Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
978 "Charles_F_Ritchel"};
979 double data[DIM6_LEN];
980 nc_type xtype_in;
981 char name_in[NC_MAX_NAME + 1];
982 int shuffle_in, deflate_in, deflate_level_in;
983 int checksum_in;
984 int i;
985
986 /* Create some phoney data. */
987 for (i = 1, data[0] = TEN_K_M2; i < DIM6_LEN; i++)
988 data[i] = data[i - 1] + INCREMENT;
989
990 /* Create a netcdf-4 file with one dim and 5 NC_DOUBLE vars. */
991 if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
992 if (nc_def_dim(ncid, DIM6_NAME, DIM6_LEN, &dimids[0])) ERR;
993 for (i = 0; i < NVARS; i++)
994 {
995 if (nc_def_var(ncid, var_name[i], NC_DOUBLE, NDIMS, dimids,
996 &varid[i])) ERR;
997 if (nc_def_var_deflate(ncid, varid[i], NC_NOSHUFFLE, 1, 0)) ERR;
998 if (nc_def_var_fletcher32(ncid, varid[i], NC_FLETCHER32)) ERR;
999 }
1000
1001 /* Check stuff. */
1002 if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
1003 if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
1004 unlimdimid != -1) ERR;
1005 if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
1006 if (nvars != NVARS) ERR;
1007 for (i = 0; i < NVARS; i++)
1008 if (varids_in[i] != i) ERR;
1009 for (i = 0; i < NVARS; i++)
1010 {
1011 if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
1012 dimids_in, &natts)) ERR;
1013 if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE ||
1014 ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
1015 if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
1016 &deflate_level_in)) ERR;
1017 if (shuffle_in != NC_NOSHUFFLE || !deflate_in || deflate_level_in != 0) ERR;
1018 if (nc_inq_var_fletcher32(ncid, varid[i], &checksum_in)) ERR;
1019 if (checksum_in != NC_FLETCHER32) ERR;
1020 }
1021
1022 if (nc_close(ncid)) ERR;
1023
1024 /* Open the file and check the same stuff. */
1025 if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
1026 if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
1027 if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
1028 unlimdimid != -1) ERR;
1029 if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
1030 if (nvars != NVARS) ERR;
1031 for (i = 0; i < NVARS; i++)
1032 if (varids_in[i] != i) ERR;
1033 for (i = 0; i < NVARS; i++)
1034 {
1035 if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
1036 dimids_in, &natts)) ERR;
1037 if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE ||
1038 ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
1039 if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
1040 &deflate_level_in)) ERR;
1041 if (shuffle_in != NC_NOSHUFFLE || !deflate_in ||
1042 deflate_level_in != 0) ERR;
1043 if (nc_inq_var_fletcher32(ncid, varid[i], &checksum_in)) ERR;
1044 if (checksum_in != NC_FLETCHER32) ERR;
1045 }
1046
1047 if (nc_close(ncid)) ERR;
1048 }
1049
1050 SUMMARIZE_ERR;
1051 #define DIM7_LEN 2
1052 #define DIM7_NAME "dim_7_from_Indiana"
1053 #define VAR7_NAME "var_7_from_Idaho"
1054 #define VAR8_NAME "var_8_from_Outer_Space"
1055 #define VAR9_NAME "var_9_from_Inner_Space"
1056 #define VAR10_NAME "var_10_from_Im_Out_Of_Ideas"
1057 #define NDIMS 1
1058
1059 printf("*** testing fill values...");
1060 {
1061 int dimids[NDIMS], dimids_in[NDIMS];
1062 size_t index[NDIMS];
1063 int varid, varid2, varid3, varid4, ndims, natts;
1064 nc_type xtype_in;
1065 char name_in[NC_MAX_NAME + 1];
1066 int shuffle_in, deflate_in, deflate_level_in;
1067 int checksum_in, no_fill;
1068 unsigned short ushort_data = 42, ushort_data_in, fill_value_in;
1069 unsigned short my_fill_value = 999;
1070 unsigned short my_fill_value2 = 111;
1071
1072 /* Create a netcdf-4 file with one dim and some NC_USHORT vars. */
1073 if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
1074 if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR;
1075 if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids, &varid)) ERR;
1076 if (nc_def_var(ncid, VAR8_NAME, NC_USHORT, NDIMS, dimids, &varid2)) ERR;
1077 if (nc_def_var(ncid, VAR9_NAME, NC_USHORT, NDIMS, dimids, &varid3)) ERR;
1078 if (nc_put_att(ncid, varid3, _FillValue, NC_USHORT, 1, &my_fill_value2)) ERR;
1079 if (nc_def_var(ncid, VAR10_NAME, NC_USHORT, NDIMS, dimids, &varid4)) ERR;
1080 if (nc_put_att(ncid, varid4, _FillValue, NC_USHORT, 1, &my_fill_value2)) ERR;
1081
1082 /* Check stuff. */
1083 if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in,
1084 &natts)) ERR;
1085 if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT ||
1086 ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
1087 if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
1088 &deflate_level_in)) ERR;
1089 if (shuffle_in != NC_NOSHUFFLE || deflate_in) ERR;
1090 if (nc_inq_var_fletcher32(ncid, 0, &checksum_in)) ERR;
1091 if (checksum_in != NC_NOCHECKSUM) ERR;
1092 if (nc_inq_var_fill(ncid, 0, &no_fill, &fill_value_in)) ERR;
1093 if (no_fill || fill_value_in != NC_FILL_USHORT) ERR;
1094
1095 /* Set a fill value for the second and forth variable. This will
1096 * overwrite the existing fill value attribute for varid4. */
1097 if (nc_def_var_fill(ncid, varid2, 0, &my_fill_value)) ERR;
1098 if (nc_def_var_fill(ncid, varid4, 0, &my_fill_value)) ERR;
1099
1100 /* Write the second of two values. */
1101 index[0] = 1;
1102 if (nc_put_var1_ushort(ncid, 0, index, &ushort_data)) ERR;
1103 if (nc_put_var1_ushort(ncid, varid2, index, &ushort_data)) ERR;
1104 if (nc_put_var1_ushort(ncid, varid3, index, &ushort_data)) ERR;
1105 if (nc_put_var1_ushort(ncid, varid4, index, &ushort_data)) ERR;
1106
1107 /* Get the first value, and make sure we get the correct fill
1108 * values. */
1109 index[0] = 0;
1110 if (nc_get_var1_ushort(ncid, 0, index, &ushort_data_in)) ERR;
1111 if (ushort_data_in != NC_FILL_USHORT) ERR;
1112 if (nc_get_var1_ushort(ncid, varid2, index, &ushort_data_in)) ERR;
1113 if (ushort_data_in != my_fill_value) ERR;
1114 if (nc_get_var1_ushort(ncid, varid3, index, &ushort_data_in)) ERR;
1115 if (ushort_data_in != my_fill_value2) ERR;
1116 if (nc_get_var1_ushort(ncid, varid4, index, &ushort_data_in)) ERR;
1117 if (ushort_data_in != my_fill_value) ERR;
1118
1119 if (nc_close(ncid)) ERR;
1120
1121 /* Open the file and check the same stuff. */
1122 if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
1123
1124 /* Check stuff. */
1125 if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
1126 dimids_in, &natts)) ERR;
1127 if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT ||
1128 ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
1129 if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
1130 &deflate_level_in)) ERR;
1131 if (shuffle_in != NC_NOSHUFFLE || deflate_in) ERR;
1132 if (nc_inq_var_fletcher32(ncid, 0, &checksum_in)) ERR;
1133 if (checksum_in != NC_NOCHECKSUM) ERR;
1134
1135 if (nc_close(ncid)) ERR;
1136 }
1137
1138 SUMMARIZE_ERR;
1139 printf("*** testing more fill values...");
1140 {
1141 int dimids[NDIMS];
1142 size_t index[NDIMS];
1143 int varid;
1144 int no_fill;
1145 unsigned short ushort_data = 42, ushort_data_in, fill_value_in;
1146 unsigned short my_fill_value = 999;
1147
1148 /* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
1149 if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
1150 if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR;
1151 if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids,
1152 &varid)) ERR;
1153
1154 /* Turn off fill mode. */
1155 if (nc_def_var_fill(ncid, varid, 1, NULL)) ERR;
1156 if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
1157 if (!no_fill) ERR;
1158
1159 /* Turn on fill mode. */
1160 if (nc_def_var_fill(ncid, varid, 0, NULL)) ERR;
1161 if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
1162 if (no_fill) ERR;
1163
1164 /* Turn off fill mode. */
1165 if (nc_def_var_fill(ncid, varid, 1, NULL)) ERR;
1166 if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
1167 if (!no_fill) ERR;
1168
1169 /* Try and set a fill value and fill mode off. It will be
1170 * ignored because fill mode is off. */
1171 if (nc_def_var_fill(ncid, varid, 1, &my_fill_value)) ERR;
1172
1173 /* Turn on fill mode. */
1174 if (nc_def_var_fill(ncid, varid, 0, NULL)) ERR;
1175 if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
1176 if (fill_value_in != NC_FILL_USHORT) ERR;
1177 if (no_fill) ERR;
1178
1179 /* Write the second of two values. */
1180 index[0] = 1;
1181 if (nc_put_var1_ushort(ncid, varid, index, &ushort_data)) ERR;
1182
1183 /* Get the first value, and make sure we get the default fill
1184 * value for USHORT. */
1185 index[0] = 0;
1186 if (nc_get_var1_ushort(ncid, varid, index, &ushort_data_in)) ERR;
1187 if (ushort_data_in != NC_FILL_USHORT) ERR;
1188 if (nc_close(ncid)) ERR;
1189
1190 /* Open the file and check the same stuff. */
1191 if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
1192
1193 /* Check stuff. */
1194 if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
1195 if (no_fill) ERR;
1196
1197 if (nc_close(ncid)) ERR;
1198 }
1199
1200 SUMMARIZE_ERR;
1201 printf("*** testing fill values for 2D unlimited dimension variable...");
1202 {
1203 #define D1_NAME "unlimited"
1204 #define D1_LEN 4
1205 #define D1_TARGET 3
1206 #define D2_NAME "fixed"
1207 #define D2_LEN 3
1208 #define D2_TARGET 2
1209 #define V1_NAME "var1"
1210 #define ND1 2
1211 #define TARGET_VALUE 42
1212
1213 int dimids[ND1];
1214 size_t index[ND1];
1215 int varid;
1216 int no_fill;
1217 int data = TARGET_VALUE, data_in[D1_LEN][D2_LEN], fill_value_in;
1218 int i, j;
1219
1220 /* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
1221 if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
1222 if (nc_def_dim(ncid, D1_NAME, NC_UNLIMITED, &dimids[0])) ERR;
1223 if (nc_def_dim(ncid, D2_NAME, D2_LEN, &dimids[1])) ERR;
1224 if (nc_def_var(ncid, V1_NAME, NC_INT, ND1, dimids, &varid)) ERR;
1225
1226 /* Check stuff. */
1227 if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
1228 if (no_fill) ERR;
1229
1230 /* Write a value. */
1231 index[0] = D1_TARGET;
1232 index[1] = D2_TARGET;
1233 if (nc_put_var1_int(ncid, varid, index, &data)) ERR;
1234
1235 /* Get the data, and check the values. */
1236 if (nc_get_var_int(ncid, 0, &data_in[0][0])) ERR;
1237 for (i = 0; i < D1_TARGET; i++)
1238 for (j = 0; j < D2_LEN; j++)
1239 if ((i == D1_TARGET && j == D2_TARGET && data_in[i][j] != TARGET_VALUE) ||
1240 data_in[i][j] != NC_FILL_INT) ERR;
1241
1242 if (nc_close(ncid)) ERR;
1243
1244 /* Open the file and check the same stuff. */
1245 if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
1246
1247 /* Get the data, and check the values. */
1248 if (nc_get_var_int(ncid, 0, &data_in[0][0])) ERR;
1249 for (i = 0; i < D1_TARGET; i++)
1250 for (j = 0; j < D2_LEN; j++)
1251 if ((i == D1_TARGET && j == D2_TARGET && data_in[i][j] != TARGET_VALUE) ||
1252 data_in[i][j] != NC_FILL_INT) ERR;
1253
1254 if (nc_close(ncid)) ERR;
1255 }
1256
1257 SUMMARIZE_ERR;
1258 printf("*** testing lots of variables...");
1259 #define DIM_A_NAME "x"
1260 #define DIM_A_LEN 10
1261 #define NUM_VARS 2000
1262 #define MAX_VARNAME 10
1263 {
1264 /* This simple test failed on HDF5 1.7.58, but passes just fine
1265 * on 1.8.0 alpha5... */
1266 int ncid, dimids[1], i;
1267 char varname[MAX_VARNAME];
1268 int varids[NUM_VARS];
1269
1270 /* Create a file with three dimensions. */
1271 if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
1272 if (nc_def_dim(ncid, DIM_A_NAME, DIM_A_LEN, &dimids[0])) ERR;
1273
1274 /* Create a large number of variables. */
1275 for (i = 0; i < NUM_VARS; i++)
1276 {
1277 sprintf(varname, "a_%d", i);
1278 if (nc_def_var(ncid, varname, NC_FLOAT, 1, dimids, &varids[i])) {
1279 ERR;
1280 break;
1281 }
1282 }
1283 if (nc_close(ncid)) ERR;
1284 }
1285 SUMMARIZE_ERR;
1286
1287 #define NC3_CLASSIC_FILE "tst_pres_temp_4D_classic.nc"
1288 #define NC3_64BIT_OFFSET_FILE "tst_pres_temp_4D_64bit_offset.nc"
1289 #define NC3_NETCDF4_FILE "tst_pres_temp_4D_netcdf4.nc"
1290 #define NC3_NETCDF4_CLASSIC_FILE "tst_pres_temp_4D_netcdf4_classic.nc"
1291
1292 printf("*** testing 4D example file in classic format...");
1293 if (create_4D_example(NC3_CLASSIC_FILE, NC_CLOBBER)) ERR;
1294 if (check_4D_example(NC3_CLASSIC_FILE, NC_FORMAT_CLASSIC)) ERR;
1295 SUMMARIZE_ERR;
1296
1297 printf("*** testing 4D example file in 64-bit offset format...");
1298 if (create_4D_example(NC3_64BIT_OFFSET_FILE, NC_CLOBBER|NC_64BIT_OFFSET)) ERR;
1299 if (check_4D_example(NC3_64BIT_OFFSET_FILE, NC_FORMAT_64BIT_OFFSET)) ERR;
1300 SUMMARIZE_ERR;
1301
1302 printf("*** testing 4D example file in netCDF-4/HDF5 format...");
1303 if (create_4D_example(NC3_NETCDF4_FILE, NC_CLOBBER|NC_NETCDF4)) ERR;
1304 if (check_4D_example(NC3_NETCDF4_FILE, NC_FORMAT_NETCDF4)) ERR;
1305 SUMMARIZE_ERR;
1306
1307 printf("*** testing 4D example file in netCDF-4/HDF5 format with classic model rules...");
1308 if (create_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL)) ERR;
1309 if (check_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_FORMAT_NETCDF4_CLASSIC)) ERR;
1310 SUMMARIZE_ERR;
1311
1312 FINAL_RESULTS;
1313 }
1314