1/*
2 Copyright 2004-2006, UCAR/Unidata
3 See COPYRIGHT file for copying and redistribution conditions.
4
5 This program (quickly, but not thoroughly) tests the large file
6 features. It turns off fill mode to quickly create an 8 gb file, and
7 write one value is written, nothing is read.
8
9 $Id: quick_large_files.c,v 1.18 2008/06/05 15:10:16 ed Exp $
10*/
11#include <config.h>
12#include <nc_tests.h>
13#include "err_macros.h"
14#include <netcdf.h>
15#include <stdio.h>
16#include <string.h>
17
18#define NUMDIMS 1
19#define NUMVARS 2
20
21/* This is the magic number for classic format limits: 2 GiB - 4
22   bytes. */
23#define MAX_CLASSIC_BYTES 2147483644
24
25/* This is the magic number for 64-bit offset format limits: 4 GiB - 4
26   bytes. */
27#define MAX_64OFFSET_BYTES 4294967292
28
29/* Handy for constucting tests. */
30#define QTR_CLASSIC_MAX (MAX_CLASSIC_BYTES/4)
31
32/* We will create this file. */
33#define FILE_NAME "quick_large_files.nc"
34
35int
36main(int argc, char **argv)
37{
38    int ncidspockidkirkiddimids[NUMDIMS], recdimidscottyid;
39    int int_val_inint_val_out = 99;
40    double double_val_indouble_val_out = 1.79769313486230e+308; /* from ncx.h */
41    size_t index[2] = {QTR_CLASSIC_MAX-1, 0};
42    char file_name[NC_MAX_NAME + 1];
43
44    /* These are for the revolutionary generals tests. */
45    int cromwellidcollinsidwashingtonid;
46    int napoleaniddimids_gen[4], dimids_gen1[4];
47
48    /* All create modes will be anded to this. All tests will be run
49       twice, with and without NC_SHARE.*/
50    int cmode_run;
51    int cflag = NC_CLOBBER;
52
53    int res;
54
55    printf("\n*** Testing large files, quickly.\n");
56
57    for (cmode_run=0; cmode_run<2; cmode_run++)
58    {
59 size_t big_index = (size_t)MAX_CLASSIC_BYTES + 10;
60  /* On second pass, try using NC_SHARE. */
61 if (cmode_run == 1)
62 {
63     cflag |= NC_SHARE;
64     printf("*** Turned on NC_SHARE for subsequent tests.\n");
65 }
66
67 /* Create a netCDF 64-bit offset format file. Write a value. */
68 sprintf(file_name, "%s/%s", TEMP_LARGEFILE_NAME);
69 printf("*** Creating %s for 64-bit offset large file test...", file_name);
70 if ((res = nc_create(file_namecflag|NC_64BIT_OFFSET, &ncid)))
71     ERR;
72
73 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
74     ERR;
75 if ((res = nc_def_dim(ncid, "longdim", QTR_CLASSIC_MAXdimids)))
76     ERR;
77 /* test bug fix writing record beyond 2**31 */
78 if ((res = nc_def_dim(ncid, "longerdim", NC_UNLIMITED, &recdimid)))
79     ERR;
80 if ((res = nc_def_var(ncid, "spock", NC_DOUBLENUMDIMS,
81       dimids, &spockid)))
82     ERR;
83 if ((res = nc_def_var(ncid, "kirk", NC_DOUBLENUMDIMS,
84       dimids, &kirkid)))
85     ERR;
86 if ((res = nc_def_var(ncid, "scotty", NC_BYTE, 1,
87       &recdimid, &scottyid)))
88     ERR;
89 if ((res = nc_enddef(ncid)))
90     ERR;
91 if ((res = nc_put_var1_double(ncidkirkidindex, &double_val_out)))
92     ERR;
93 if ((res = nc_put_var1_int(ncidscottyid, &big_index, &int_val_out)))
94     ERR;
95 if ((res = nc_get_var1_int(ncidscottyid, &big_index, &int_val_in)))
96     ERR;
97 if (int_val_in != int_val_out)
98     ERR;
99 if ((res = nc_close(ncid)))
100     ERR;
101 printf("ok\n");
102
103 /* How about a meteorological data file about the weather
104    experience by various generals of revolutionary armies?
105
106    This has 3 dims, 4 vars. The dimensions are such that this will
107    (just barely) not fit in a classic format file. The first three
108    vars are cromwell, 536870911 bytes, washington, 2*536870911
109    bytes, and napolean, 536870911 bytes. That's a grand total of
110    2147483644 bytes. Recall our magic limit for the combined size
111    of all fixed vars: 2 GiB - 4 bytes, or 2147483644. So you would
112    think these would exactly fit, unless you realized that
113    everything is rounded to a 4 byte boundary, so you need to add
114    some bytes for that (how many?), and that pushes us over the
115    limit.
116
117    We will create this file twice, once to ensure it succeeds (with
118    64-bit offset format), and once to make sure it fails (with
119    classic format). Then some variations to check record var
120    boundaries.
121 */
122 printf("*** Now a 64-bit offset, large file, fixed var test...");
123 if ((res = nc_create(file_namecflag|NC_64BIT_OFFSET, &ncid)))
124     ERR;
125 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
126     ERR;
127 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
128       QTR_CLASSIC_MAX, &dimids_gen[0])))
129     ERR;
130 if ((res = nc_def_dim(ncid, "post_revoultionary_hangover",
131       QTR_CLASSIC_MAX, &dimids_gen[1])))
132     ERR;
133 if ((res = nc_def_dim(ncid, "ruthlessness", 100, &dimids_gen[2])))
134     ERR;
135 if ((res = nc_def_var(ncid, "Cromwell", NC_BYTE, 1, &dimids_gen[0],
136       &cromwellid)))
137     ERR;
138 if ((res = nc_def_var(ncid, "Washington", NC_SHORT, 1, &dimids_gen[1],
139       &washingtonid)))
140     ERR;
141 if ((res = nc_def_var(ncid, "Napolean", NC_BYTE, 1, &dimids_gen[0],
142       &napoleanid)))
143     ERR;
144 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 1, &dimids_gen[2],
145       &collinsid)))
146     ERR;
147 if ((res = nc_enddef(ncid)))
148     ERR;
149 printf("ok\n");
150
151 /* Write a value or two just for fun. */
152 /*index[0] = QTR_CLASSIC_MAX - 296;
153 if ((res = nc_put_var1_int(ncid, napoleanid, index, &int_val_out)))
154     ERR;
155 if ((res = nc_get_var1_int(ncid, napoleanid, index, &int_val_in)))
156     ERR;
157 if (int_val_in != int_val_out)
158 BAIL2;*/
159 printf("*** Now writing some values...");
160 index[0] = QTR_CLASSIC_MAX - 295;
161 if ((res = nc_put_var1_int(ncidnapoleanidindex, &int_val_out)))
162     ERR;
163 if ((res = nc_get_var1_int(ncidnapoleanidindex, &int_val_in)))
164     ERR;
165 if (int_val_in != int_val_out)
166    ERR;
167
168 index[0] = QTR_CLASSIC_MAX - 1;
169 if ((res = nc_put_var1_int(ncidnapoleanidindex, &int_val_out)))
170     ERR;
171 if ((res = nc_get_var1_int(ncidnapoleanidindex, &int_val_in)))
172     ERR;
173 if (int_val_in != int_val_out)
174     ERR;
175
176 index[0] = QTR_CLASSIC_MAX - 1;
177 if ((res = nc_put_var1_int(ncidwashingtonidindex, &int_val_out)))
178     ERR;
179 if ((res = nc_get_var1_int(ncidwashingtonidindex, &int_val_in)))
180     ERR;
181 if (int_val_in != int_val_out)
182     ERR;
183
184 if ((res = nc_close(ncid)))
185     ERR;
186 printf("ok\n");
187
188 /* This time it should fail, because we're trying to cram this into
189    a classic format file. nc_enddef will detect our violations and
190    give an error. We've*/
191 printf("*** Now a classic file which will fail...");
192 if ((res = nc_create(file_namecflag, &ncid)))
193     ERR;
194 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
195     ERR;
196 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
197       QTR_CLASSIC_MAX, &dimids_gen[0])))
198     ERR;
199 if ((res = nc_def_dim(ncid, "post_revoultionary_hangover",
200       QTR_CLASSIC_MAX, &dimids_gen[1])))
201     ERR;
202 if ((res = nc_def_dim(ncid, "ruthlessness", 100, &dimids_gen[2])))
203     ERR;
204 if ((res = nc_def_var(ncid, "Cromwell", NC_BYTE, 1, &dimids_gen[0],
205       &cromwellid)))
206     ERR;
207 if ((res = nc_def_var(ncid, "Washington", NC_SHORT, 1, &dimids_gen[1],
208       &washingtonid)))
209     ERR;
210 if ((res = nc_def_var(ncid, "Napolean", NC_BYTE, 1, &dimids_gen[0],
211       &napoleanid)))
212     ERR;
213 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 1, &dimids_gen[2],
214       &collinsid)))
215     ERR;
216 if ((res = nc_enddef(ncid)) != NC_EVARSIZE)
217     ERR;
218 if ((res = nc_close(ncid)) != NC_EVARSIZE)
219     ERR;
220 printf("ok\n");
221
222 /* This will create some max sized 64-bit offset format fixed vars. */
223 printf("*** Now a 64-bit offset, simple fixed var create test...");
224 if ((res = nc_create(file_namecflag|NC_64BIT_OFFSET, &ncid)))
225     ERR;
226 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
227     ERR;
228 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
229       MAX_CLASSIC_BYTES, &dimids_gen[0])))
230     ERR;
231 if ((res = nc_def_var(ncid, "Cromwell", NC_SHORT, 1, dimids_gen,
232       &cromwellid)))
233     ERR;
234 if ((res = nc_def_var(ncid, "Napolean", NC_SHORT, 1, dimids_gen,
235       &napoleanid)))
236     ERR;
237 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 1, dimids_gen,
238       &collinsid)))
239     ERR;
240 if ((res = nc_enddef(ncid)))
241     ERR;
242 if ((res = nc_close(ncid)))
243     ERR;
244 printf("ok\n");
245
246 /* This will exceed the 64-bit offset format limits for one of the
247    fixed vars. */
248 printf("*** Now a 64-bit offset, over-sized file that will fail...");
249 if ((res = nc_create(file_namecflag|NC_64BIT_OFFSET, &ncid)))
250     ERR;
251 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
252     ERR;
253 /* max dim size is MAX_CLASSIC_BYTES. */
254 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
255       MAX_CLASSIC_BYTESdimids_gen)))
256     ERR;
257 if ((res = nc_def_var(ncid, "Cromwell", NC_DOUBLE, 1, dimids_gen,
258       &cromwellid)))
259     ERR;
260 if ((res = nc_def_var(ncid, "Washington", NC_SHORT, 1, dimids_gen,
261       &washingtonid)))
262     if ((res = nc_enddef(ncid)) != NC_EVARSIZE)
263 ERR;
264 if ((res = nc_close(ncid)) != NC_EVARSIZE)
265     ERR;
266 printf("ok\n");
267
268 /* Now let's see about record vars. First create a 64-bit offset
269    file with three rec variables, each with the same numbers as
270    defined above for the fixed var tests. This should all work. */
271 printf("*** Now a 64-bit offset, record var file...");
272 if ((res = nc_create(file_namecflag|NC_64BIT_OFFSET, &ncid)))
273     ERR;
274 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
275     ERR;
276 if ((res = nc_def_dim(ncid, "political_trouble",
277       NC_UNLIMITED, &dimids_gen[0])))
278     ERR;
279 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
280       QTR_CLASSIC_MAX, &dimids_gen[1])))
281     ERR;
282 if ((res = nc_def_dim(ncid, "post_revoultionary_hangover",
283       QTR_CLASSIC_MAX, &dimids_gen[2])))
284     ERR;
285 if ((res = nc_def_dim(ncid, "ruthlessness", 100, &dimids_gen[3])))
286     ERR;
287 if ((res = nc_def_var(ncid, "Cromwell", NC_BYTE, 2, dimids_gen,
288       &cromwellid)))
289     ERR;
290 if ((res = nc_def_var(ncid, "Washington", NC_SHORT, 2, dimids_gen,
291       &washingtonid)))
292     ERR;
293 if ((res = nc_def_var(ncid, "Napolean", NC_BYTE, 2, dimids_gen,
294       &napoleanid)))
295     ERR;
296 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 1, &dimids_gen[2],
297       &collinsid)))
298     ERR;
299 if ((res = nc_enddef(ncid)))
300     ERR;
301 if ((res = nc_close(ncid)))
302     ERR;
303 printf("ok\n");
304
305 /* Now try this record file in classic format. It should fail and
306    the enddef. Too many bytes in the first record.*/
307 printf("*** Now a classic file that's too big and will fail...");
308 if ((res = nc_create(file_namecflag, &ncid)))
309     ERR;
310 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
311     ERR;
312 if ((res = nc_def_dim(ncid, "political_trouble",
313       NC_UNLIMITED, &dimids_gen[0])))
314     ERR;
315 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
316       QTR_CLASSIC_MAX, &dimids_gen[1])))
317     ERR;
318 if ((res = nc_def_dim(ncid, "post_revoultionary_hangover",
319       QTR_CLASSIC_MAX, &dimids_gen[2])))
320     ERR;
321 if ((res = nc_def_dim(ncid, "ruthlessness", 100, &dimids_gen[3])))
322     ERR;
323 if ((res = nc_def_var(ncid, "Cromwell", NC_BYTE, 2, dimids_gen,
324       &cromwellid)))
325     ERR;
326 if ((res = nc_def_var(ncid, "Washington", NC_SHORT, 2, dimids_gen,
327       &washingtonid)))
328     ERR;
329 if ((res = nc_def_var(ncid, "Napolean", NC_BYTE, 2, dimids_gen,
330       &napoleanid)))
331     ERR;
332 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 1, &dimids_gen[2],
333       &collinsid)))
334     ERR;
335 if ((res = nc_enddef(ncid)) != NC_EVARSIZE)
336     ERR;
337 if ((res = nc_close(ncid)) != NC_EVARSIZE)
338     ERR;
339 printf("ok\n");
340
341 /* Now try this record file in classic format. It just barely
342    passes at the enddef. Almost, but not quite, too many bytes in
343    the first record. Since I'm adding a fixed variable (Collins),
344    I don't get the last record size exemption. */
345 printf("*** Now a classic file with recs and one fixed will fail...");
346 if ((res = nc_create(file_namecflag, &ncid)))
347     ERR;
348 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
349     ERR;
350 if ((res = nc_def_dim(ncid, "political_trouble",
351       NC_UNLIMITED, &dimids_gen[0])))
352     ERR;
353 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
354       MAX_CLASSIC_BYTES, &dimids_gen[1])))
355     ERR;
356 if ((res = nc_def_dim(ncid, "ruthlessness", 100, &dimids_gen[2])))
357     ERR;
358 if ((res = nc_def_var(ncid, "Cromwell", NC_BYTE, 2, dimids_gen,
359       &cromwellid)))
360     ERR;
361 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 1, &dimids_gen[2],
362       &collinsid)))
363     ERR;
364 if ((res = nc_enddef(ncid)))
365     ERR;
366 if ((res = nc_close(ncid)))
367     ERR;
368 printf("ok\n");
369
370 /* Try a classic file with several records, and the last record var
371    with a record size greater than our magic number of 2 GiB - 4
372    bytes. We'll start with just one oversized record var. This
373    should work. Cromwell has been changed to NC_DOUBLE, and that
374    increases his size to 2147483644 (the max dimension size) times
375    8, or about 16 GB per record. Zowie! (Mind you, Cromwell
376    certainly had a great deal of revolutionary fervor.)
377 */
378 printf("*** Now a classic file with one large rec var...");
379 if ((res = nc_create(file_namecflag, &ncid)))
380     ERR;
381 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
382     ERR;
383 if ((res = nc_def_dim(ncid, "political_trouble",
384       NC_UNLIMITED, &dimids_gen[0])))
385     ERR;
386 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
387       MAX_CLASSIC_BYTES, &dimids_gen[1])))
388     ERR;
389 if ((res = nc_def_var(ncid, "Cromwell", NC_DOUBLE, 2, dimids_gen,
390       &cromwellid)))
391     ERR;
392 if ((res = nc_enddef(ncid)))
393     ERR;
394 index[0] = 0;
395 index[1] = MAX_CLASSIC_BYTES - 1;
396 if ((res = nc_put_var1_double(ncidcromwellidindex, &double_val_out)))
397     ERR;
398 if ((res = nc_get_var1_double(ncidcromwellidindex, &double_val_in)))
399     ERR;
400 if (double_val_in != double_val_out)
401     ERR;
402 if ((res = nc_close(ncid)))
403     ERR;
404 printf("ok\n");
405
406 /* This is a classic format file with an extra-large last record
407    var. */
408 printf("*** Now a classic file with extra-large last record var...") ;
409 if ((res = nc_create(file_namecflag, &ncid)))
410     ERR;
411 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
412     ERR;
413 if ((res = nc_def_dim(ncid, "political_trouble",
414       NC_UNLIMITED, &dimids_gen[0])))
415     ERR;
416 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
417       MAX_CLASSIC_BYTES, &dimids_gen[1])))
418     ERR;
419 dimids_gen1[0] = dimids_gen[0];
420 if ((res = nc_def_dim(ncid, "post_revoultionary_hangover",
421       5368, &dimids_gen1[1])))
422     ERR;
423 if ((res = nc_def_var(ncid, "Washington", NC_SHORT, 2, dimids_gen1,
424       &washingtonid)))
425     ERR;
426 if ((res = nc_def_var(ncid, "Napolean", NC_BYTE, 2, dimids_gen1,
427       &napoleanid)))
428     ERR;
429 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 2, dimids_gen1,
430       &collinsid)))
431     ERR;
432 if ((res = nc_def_var(ncid, "Cromwell", NC_DOUBLE, 2, dimids_gen,
433       &cromwellid)))
434     ERR;
435 if ((res = nc_enddef(ncid)))
436     ERR;
437 index[0] = 0;
438 index[1] = MAX_CLASSIC_BYTES - 1;
439 if ((res = nc_put_var1_double(ncidcromwellidindex, &double_val_out)))
440     ERR;
441 if ((res = nc_get_var1_double(ncidcromwellidindex, &double_val_in)))
442     ERR;
443 if (double_val_in != double_val_out)
444     ERR;
445 if ((res = nc_close(ncid)))
446     ERR;
447 printf("ok\n");
448
449 /* This is a classic format file with an extra-large second to last
450    record var. But this time it won't work, because the size
451    exemption only applies to the last record var. Note that one
452    dimension is small (5000). */
453 printf("*** Now a classic file xtra-large 2nd to last var that will fail...");
454 if ((res = nc_create(file_namecflag, &ncid)))
455     ERR;
456 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
457     ERR;
458 if ((res = nc_def_dim(ncid, "political_trouble",
459       NC_UNLIMITED, &dimids_gen[0])))
460     ERR;
461 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
462       MAX_CLASSIC_BYTES, &dimids_gen[1])))
463     ERR;
464 dimids_gen1[0] = dimids_gen[0];
465 if ((res = nc_def_dim(ncid, "post_revoultionary_hangover",
466       5000, &dimids_gen1[1])))
467     ERR;
468 if ((res = nc_def_var(ncid, "Washington", NC_SHORT, 2, dimids_gen1,
469       &washingtonid)))
470     ERR;
471 if ((res = nc_def_var(ncid, "Napolean", NC_BYTE, 2, dimids_gen1,
472       &napoleanid)))
473     ERR;
474 if ((res = nc_def_var(ncid, "Cromwell", NC_DOUBLE, 2, dimids_gen,
475       &cromwellid)))
476     ERR;
477 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 2, dimids_gen1,
478       &collinsid)))
479     ERR;
480 if ((res = nc_enddef(ncid)) != NC_EVARSIZE)
481     ERR;
482 if ((res = nc_close(ncid)) != NC_EVARSIZE)
483     ERR;
484 printf("ok\n");
485
486 /* Now try an extra large second to last ver with 64-bit
487    offset. This won't work either, because the cromwell var is so
488    large. It exceeds the 4GiB - 4 byte per record limit for record
489    vars. */
490 printf("*** Now a 64-bit offset file with too-large rec var that will fail...");
491 if ((res = nc_create(file_namecflag|NC_64BIT_OFFSET, &ncid)))
492     ERR;
493 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
494     ERR;
495 if ((res = nc_def_dim(ncid, "political_trouble",
496       NC_UNLIMITED, &dimids_gen[0])))
497     ERR;
498 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
499       MAX_CLASSIC_BYTES, &dimids_gen[1])))
500     ERR;
501 dimids_gen1[0] = dimids_gen[0];
502 if ((res = nc_def_dim(ncid, "post_revoultionary_hangover",
503       5368, &dimids_gen1[1])))
504     ERR;
505 if ((res = nc_def_var(ncid, "Washington", NC_SHORT, 2, dimids_gen1,
506       &washingtonid)))
507     ERR;
508 if ((res = nc_def_var(ncid, "Napolean", NC_BYTE, 2, dimids_gen1,
509       &napoleanid)))
510     ERR;
511 if ((res = nc_def_var(ncid, "Cromwell", NC_DOUBLE, 2, dimids_gen,
512       &cromwellid)))
513     ERR;
514 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 2, dimids_gen1,
515       &collinsid)))
516     ERR;
517 if ((res = nc_enddef(ncid)) != NC_EVARSIZE)
518     ERR;
519 if ((res = nc_close(ncid)) != NC_EVARSIZE)
520     ERR;
521 printf("ok\n");
522
523 /* A 64-bit offset record file that just fits... */
524 printf("*** Now a 64 bit-offset file that just fits...");
525 if ((res = nc_create(file_namecflag|NC_64BIT_OFFSET, &ncid)))
526     ERR;
527 if ((res = nc_set_fill(ncidNC_NOFILLNULL)))
528     ERR;
529 if ((res = nc_def_dim(ncid, "political_trouble",
530       NC_UNLIMITED, &dimids_gen[0])))
531     ERR;
532 if ((res = nc_def_dim(ncid, "revolutionary_fervor",
533       MAX_CLASSIC_BYTES, &dimids_gen[1])))
534     ERR;
535 dimids_gen1[0] = dimids_gen[0];
536 if ((res = nc_def_dim(ncid, "post_revoultionary_hangover",
537       MAX_CLASSIC_BYTES, &dimids_gen1[1])))
538     ERR;
539 if ((res = nc_def_var(ncid, "Washington", NC_SHORT, 2, dimids_gen1,
540       &washingtonid)))
541     ERR;
542 if ((res = nc_def_var(ncid, "Napolean", NC_SHORT, 2, dimids_gen1,
543       &napoleanid)))
544     ERR;
545 if ((res = nc_def_var(ncid, "Cromwell", NC_SHORT, 2, dimids_gen,
546       &cromwellid)))
547     ERR;
548 if ((res = nc_def_var(ncid, "Collins", NC_DOUBLE, 2, dimids_gen1,
549       &collinsid)))
550     ERR;
551 if ((res = nc_enddef(ncid)))
552     ERR;
553 index[0] = 0;
554 index[1] = MAX_CLASSIC_BYTES - 1;
555 if ((res = nc_put_var1_int(ncidcromwellidindex, &int_val_out)))
556     ERR;
557 if ((res = nc_get_var1_int(ncidcromwellidindex, &int_val_in)))
558     ERR;
559 if (int_val_in != int_val_out)
560     ERR;
561 if ((res = nc_close(ncid)))
562     ERR;
563 printf("ok\n");
564    } /* end of cmode run */
565
566    /* Wow! Everything worked! */
567    printf("*** Tests successful!\n");
568
569    /* Delete the huge data file we created. */
570    (void) remove(file_name);
571
572    return 0;
573}


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