1/*********************************************************************
2 *   Copyright 1996-2005, UCAR/Unidata
3 *   See COPYRIGHT file for copying and redistribution conditions.
4 *   $Id: nc_test.c 2796 2014-10-28 03:40:29Z wkliao $
5 *********************************************************************/
6
7int numGatts;  /* number of global attributes */
8int numVars;   /* number of variables */
9int numTypes;  /* number of netCDF data types to test */
10
11#include "tests.h"
12
13/*
14 * Test driver for netCDF-3 interface.  This program performs tests against
15 * the netCDF-3 specification for all user-level functions in an
16 * implementation of the netCDF library.
17 *
18 * Files:
19 * The read-only tests read files:
20 *     test.nc (see below)
21 *     tests.h (used merely as an example of a non-netCDF file)
22 *
23 * The write tests
24 *     read test.nc (see below)
25 *     write scratch.nc (deleted after each test)
26 *
27 * The file test.nc is created by running nc_test with the -c (create) option.
28 * It is described by the following global variables.
29 */
30
31/*
32 * global variables (defined by function init_gvars) describing file test.nc
33 */
34char dim_name[NDIMS][3];
35size_t dim_len[NDIMS];
36char var_name[NVARS][2+MAX_RANK];
37nc_type var_type[NVARS];
38size_t var_rank[NVARS];
39int var_dimid[NVARS][MAX_RANK];
40size_t var_shape[NVARS][MAX_RANK];
41size_t var_nels[NVARS];
42size_t var_natts[NVARS];
43char att_name[NVARS][MAX_NATTS][2];
44char gatt_name[NGATTS][3];
45nc_type att_type[NVARS][NGATTS];
46nc_type gatt_type[NGATTS];
47size_t att_len[NVARS][MAX_NATTS];
48size_t gatt_len[NGATTS];
49
50/*
51 * command-line options
52 */
53int  verbose; /* if 1, print details of tests */
54int  max_nmpt; /* max. number of messages per test */
55
56/*
57 * Misc. global variables
58 */
59int  nfails; /* number of failures in specific test */
60char testfile[NC_MAX_NAME];
61char scratch[] = "scratch.nc";  /* writable scratch file */
62
63#define NC_TEST(func) \
64    print( "*** testing " #func " ... ");\
65    nfails = 0;\
66    test_ ## func();\
67    nfailsTotal += nfails;\
68    if (verbose) \
69 print("\n"); \
70    if ( nfails == 0) \
71        print( "ok\n");\
72    else\
73        print( "\n\t### %d FAILURES TESTING %s! ###\n", nfails, #func)
74
75
76#if 1 /* both CRAY MPP and OSF/1 Alpha systems need this */
77#include <signal.h>
78#endif /* T90 */
79
80/* Test everything for classic and 64-bit offsetfiles. If netcdf-4 is
81 * included, that means another whole round of testing. */
82#define NUM_FORMATS (5)
83
84int
85main(int argc, char *argv[])
86{
87    int i;
88    int  nfailsTotal = 0;        /* total number of failures */
89
90#ifdef USE_PNETCDF
91    MPI_Init(&argc, &argv);
92#endif
93    /* Both CRAY MPP and OSF/1 Alpha systems need this.  Some of the
94     * extreme test assignments in this program trigger floating point
95     * exceptions on CRAY T90
96     */
97    (void) signal(SIGFPESIG_IGN);
98
99    verbose = 0;
100    max_nmpt = 8;
101
102    /* If you uncomment the nc_set_log_level line, you will get a lot
103     * of debugging info. If you set the number higher, you'll get
104     * more. 6 is max, 0 shows only errors. 3 is a good place to
105     * start. */
106    /*nc_set_log_level(3);*/
107
108    fprintf(stderr, "Testing %d different netCDF formats.\n", NUM_FORMATS);
109
110    /* Go thru formats and run all tests for each of two (for netCDF-3
111     * only builds), or 3 (for netCDF-4 builds) different formats. Do
112     * the netCDF-4 format last, however, because, as an additional
113     * test, the ../nc_test4/tst_nc_test_file program looks at the
114     * output of this program. */
115    for (i = 1; i <= NUM_FORMATSi++)
116    {
117       numGatts = 6;
118       numVars  = 136;
119       numTypes = 6;
120
121       switch (i)
122       {
123   case NC_FORMAT_CLASSIC:
124      nc_set_default_format(NC_FORMAT_CLASSICNULL);
125      fprintf(stderr, "\n\nSwitching to netCDF classic format.\n");
126      strcpy(testfile, "nc_test_classic.nc");
127      break;
128   case NC_FORMAT_64BIT_OFFSET:
129      nc_set_default_format(NC_FORMAT_64BIT_OFFSETNULL);
130      fprintf(stderr, "\n\nSwitching to 64-bit offset format.\n");
131      strcpy(testfile, "nc_test_64bit.nc");
132      break;
133   case NC_FORMAT_CDF5:
134      nc_set_default_format(NC_FORMAT_CDF5NULL);
135      fprintf(stderr, "\n\nSwitching to 64-bit data format.\n");
136      strcpy(testfile, "nc_test_cdf5.nc");
137             numGatts = NGATTS;
138             numVars  = NVARS;
139             numTypes = NTYPES;
140      break;
141   case NC_FORMAT_NETCDF4_CLASSIC:
142   case NC_FORMAT_NETCDF4: /* actually it's _CLASSIC. */
143#ifdef USE_NETCDF4
144      nc_set_default_format(NC_FORMAT_NETCDF4_CLASSICNULL);
145      strcpy(testfile, "nc_test_netcdf4.nc");
146      fprintf(stderr, "\n\nSwitching to netCDF-4 format (with NC_CLASSIC_MODEL).\n");
147      break;
148#else
149      continue; /* loop i */
150#endif
151   default:
152      fprintf(stderr, "Unexpected format!\n");
153      return 2;
154       }
155
156       /* Initialize global variables defining test file */
157       init_gvars();
158
159 /* Write the test file, needed for the read-only tests below. */
160       write_file(testfile);
161
162 /* delete any existing scratch netCDF file */
163       (void) remove(scratch);
164
165 /* Test read-only functions, using pre-generated test-file */
166  NC_TEST(nc_strerror);
167 NC_TEST(nc_open);
168 NC_TEST(nc_close);
169 NC_TEST(nc_inq);
170 NC_TEST(nc_inq_dimid);
171 NC_TEST(nc_inq_dim);
172 NC_TEST(nc_inq_dimlen);
173 NC_TEST(nc_inq_dimname);
174 NC_TEST(nc_inq_varid);
175 NC_TEST(nc_inq_var);
176 NC_TEST(nc_inq_natts);
177 NC_TEST(nc_inq_ndims);
178 NC_TEST(nc_inq_nvars);
179 NC_TEST(nc_inq_unlimdim);
180 NC_TEST(nc_inq_vardimid);
181 NC_TEST(nc_inq_varname);
182 NC_TEST(nc_inq_varnatts);
183 NC_TEST(nc_inq_varndims);
184 NC_TEST(nc_inq_vartype);
185 NC_TEST(nc_get_var_text);
186 NC_TEST(nc_get_var_uchar);
187 NC_TEST(nc_get_var_schar);
188 NC_TEST(nc_get_var_short);
189 NC_TEST(nc_get_var_int);
190 NC_TEST(nc_get_var_long);
191 NC_TEST(nc_get_var_float);
192 NC_TEST(nc_get_var_double);
193 NC_TEST(nc_get_var_ushort);
194 NC_TEST(nc_get_var_uint);
195 NC_TEST(nc_get_var_longlong);
196 NC_TEST(nc_get_var_ulonglong);
197 NC_TEST(nc_get_var1_text);
198 NC_TEST(nc_get_var1_uchar);
199 NC_TEST(nc_get_var1_schar);
200 NC_TEST(nc_get_var1_short);
201 NC_TEST(nc_get_var1_int);
202 NC_TEST(nc_get_var1_long);
203 NC_TEST(nc_get_var1_float);
204 NC_TEST(nc_get_var1_double);
205 NC_TEST(nc_get_var1_ushort);
206 NC_TEST(nc_get_var1_uint);
207 NC_TEST(nc_get_var1_longlong);
208 NC_TEST(nc_get_var1_ulonglong);
209 NC_TEST(nc_get_var1);
210 NC_TEST(nc_get_vara_text);
211 NC_TEST(nc_get_vara_uchar);
212 NC_TEST(nc_get_vara_schar);
213 NC_TEST(nc_get_vara_short);
214 NC_TEST(nc_get_vara_int);
215 NC_TEST(nc_get_vara_long);
216 NC_TEST(nc_get_vara_float);
217 NC_TEST(nc_get_vara_double);
218 NC_TEST(nc_get_vara_ushort);
219 NC_TEST(nc_get_vara_uint);
220 NC_TEST(nc_get_vara_longlong);
221 NC_TEST(nc_get_vara_ulonglong);
222 NC_TEST(nc_get_vara);
223 NC_TEST(nc_get_vars_text);
224 NC_TEST(nc_get_vars_uchar);
225 NC_TEST(nc_get_vars_schar);
226 NC_TEST(nc_get_vars_short);
227 NC_TEST(nc_get_vars_int);
228 NC_TEST(nc_get_vars_long);
229 NC_TEST(nc_get_vars_float);
230 NC_TEST(nc_get_vars_double);
231 NC_TEST(nc_get_vars_ushort);
232 NC_TEST(nc_get_vars_uint);
233 NC_TEST(nc_get_vars_longlong);
234 NC_TEST(nc_get_vars_ulonglong);
235 NC_TEST(nc_get_vars);
236 NC_TEST(nc_get_varm_text);
237 NC_TEST(nc_get_varm_uchar);
238 NC_TEST(nc_get_varm_schar);
239 NC_TEST(nc_get_varm_short);
240 NC_TEST(nc_get_varm_int);
241 NC_TEST(nc_get_varm_long);
242 NC_TEST(nc_get_varm_float);
243 NC_TEST(nc_get_varm_double);
244 NC_TEST(nc_get_varm_ushort);
245 NC_TEST(nc_get_varm_uint);
246 NC_TEST(nc_get_varm_longlong);
247 NC_TEST(nc_get_varm_ulonglong);
248 NC_TEST(nc_get_varm);
249 NC_TEST(nc_get_att_text);
250 NC_TEST(nc_get_att_uchar);
251 NC_TEST(nc_get_att_schar);
252 NC_TEST(nc_get_att_short);
253 NC_TEST(nc_get_att_int);
254 NC_TEST(nc_get_att_long);
255 NC_TEST(nc_get_att_float);
256 NC_TEST(nc_get_att_double);
257 NC_TEST(nc_get_att_ushort);
258 NC_TEST(nc_get_att_uint);
259 NC_TEST(nc_get_att_longlong);
260 NC_TEST(nc_get_att_ulonglong);
261 NC_TEST(nc_get_att);
262 NC_TEST(nc_inq_att);
263 NC_TEST(nc_inq_attname);
264 NC_TEST(nc_inq_attid);
265 NC_TEST(nc_inq_attlen);
266 NC_TEST(nc_inq_atttype);
267
268 /* Test write functions */
269 NC_TEST(nc_create);
270 NC_TEST(nc_redef);
271 /* NC_TEST(nc_enddef); *//* redundant */
272 NC_TEST(nc_sync);
273 NC_TEST(nc_abort);
274 NC_TEST(nc_def_dim);
275 NC_TEST(nc_rename_dim);
276 NC_TEST(nc_def_var);
277 NC_TEST(nc_put_var_text);
278 NC_TEST(nc_put_var_uchar);
279 NC_TEST(nc_put_var_schar);
280 NC_TEST(nc_put_var_short);
281 NC_TEST(nc_put_var_int);
282 NC_TEST(nc_put_var_long);
283 NC_TEST(nc_put_var_float);
284 NC_TEST(nc_put_var_double);
285 NC_TEST(nc_put_var_ushort);
286 NC_TEST(nc_put_var_uint);
287 NC_TEST(nc_put_var_longlong);
288 NC_TEST(nc_put_var_ulonglong);
289 NC_TEST(nc_put_var1_text);
290 NC_TEST(nc_put_var1_uchar);
291 NC_TEST(nc_put_var1_schar);
292 NC_TEST(nc_put_var1_short);
293 NC_TEST(nc_put_var1_int);
294 NC_TEST(nc_put_var1_long);
295 NC_TEST(nc_put_var1_float);
296 NC_TEST(nc_put_var1_double);
297 NC_TEST(nc_put_var1_ushort);
298 NC_TEST(nc_put_var1_uint);
299 NC_TEST(nc_put_var1_longlong);
300 NC_TEST(nc_put_var1_ulonglong);
301 NC_TEST(nc_put_var1);
302 NC_TEST(nc_put_vara_text);
303 NC_TEST(nc_put_vara_uchar);
304 NC_TEST(nc_put_vara_schar);
305 NC_TEST(nc_put_vara_short);
306 NC_TEST(nc_put_vara_int);
307 NC_TEST(nc_put_vara_long);
308 NC_TEST(nc_put_vara_float);
309 NC_TEST(nc_put_vara_double);
310 NC_TEST(nc_put_vara_ushort);
311 NC_TEST(nc_put_vara_uint);
312 NC_TEST(nc_put_vara_longlong);
313 NC_TEST(nc_put_vara_ulonglong);
314 NC_TEST(nc_put_vara);
315 NC_TEST(nc_put_vars_text);
316 NC_TEST(nc_put_vars_uchar);
317 NC_TEST(nc_put_vars_schar);
318 NC_TEST(nc_put_vars_short);
319 NC_TEST(nc_put_vars_int);
320 NC_TEST(nc_put_vars_long);
321 NC_TEST(nc_put_vars_float);
322 NC_TEST(nc_put_vars_double);
323 NC_TEST(nc_put_vars_ushort);
324 NC_TEST(nc_put_vars_uint);
325 NC_TEST(nc_put_vars_longlong);
326 NC_TEST(nc_put_vars_ulonglong);
327 NC_TEST(nc_put_vars);
328 NC_TEST(nc_put_varm_text);
329 NC_TEST(nc_put_varm_uchar);
330 NC_TEST(nc_put_varm_schar);
331 NC_TEST(nc_put_varm_short);
332 NC_TEST(nc_put_varm_int);
333 NC_TEST(nc_put_varm_long);
334 NC_TEST(nc_put_varm_float);
335 NC_TEST(nc_put_varm_double);
336 NC_TEST(nc_put_varm_ushort);
337 NC_TEST(nc_put_varm_uint);
338 NC_TEST(nc_put_varm_longlong);
339 NC_TEST(nc_put_varm_ulonglong);
340 NC_TEST(nc_put_varm);
341 NC_TEST(nc_rename_var);
342 NC_TEST(nc_put_att_text);
343 NC_TEST(nc_put_att_uchar);
344 NC_TEST(nc_put_att_schar);
345 NC_TEST(nc_put_att_short);
346 NC_TEST(nc_put_att_int);
347 NC_TEST(nc_put_att_long);
348 NC_TEST(nc_put_att_float);
349 NC_TEST(nc_put_att_ulonglong);
350 NC_TEST(nc_put_att_ushort);
351 NC_TEST(nc_put_att_uint);
352 NC_TEST(nc_put_att_longlong);
353 NC_TEST(nc_put_att_ulonglong);
354 NC_TEST(nc_put_att);
355 NC_TEST(nc_copy_att);
356 NC_TEST(nc_rename_att);
357 NC_TEST(nc_del_att);
358 NC_TEST(nc_set_default_format);
359    }
360
361    fprintf(stderr, "\n*** Total number of failures: %d\n", nfailsTotal);
362
363    if (nfailsTotal)
364    {
365       fprintf(stderr, "*** nc_test FAILURE!!!\n");
366       return 2;
367    }
368    else
369       fprintf(stderr, "*** nc_test SUCCESS!!!\n");
370
371#ifdef USE_PNETCDF
372    MPI_Finalize();
373#endif
374    exit(0);
375    return 0;
376}


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