1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*********************************************************************
* Copyright 2018, UCAR/Unidata
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
* $Id: varputg.c,v 1.10 2006/10/31 16:22:06 ed Exp $
*********************************************************************/
#include <config.h>
#include <stdio.h>
#include <stdlib.h> /* for free() */
#include "netcdf.h"
#include "testcdf.h" /* defines in-memory test cdf structure */
#include "val.h"
#include "error.h"
#include "tests.h"
#include "emalloc.h"
/*
* Test ncvarputg
* check that proper call worked with ncvargetg
* try with negative coords, edges, check error
* try with too-large coords, edges, check error
* try with non-positive strides, check error
* try with bad variable handle, check error
* try in define mode, check error
* try with bad netCDF handle, check error
*/
int
test_ncvarputg(path)
const char *path; /* name of writable netcdf file to open */
{
int nerrs = 0;
static char pname[] = "test_ncvarputg";
int cdfid; /* netcdf id */
int iv; /* variable id */
struct cdfhc { /* a hypercube with generic values */
long cor[MAX_NC_DIMS]; /* netcdf coordinates for lower corner */
long edg[MAX_NC_DIMS]; /* netcdf edge lengths to upper corner */
void *vals; /* pointer to block of values */
} hc; /* test hypercube */
long tmp;
int id; /* dimension id */
long strides[MAX_NC_DIMS]; /* external, I/O strides */
(void) fprintf(stderr, "*** Testing %s ...\t", &pname[5]);
if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
error("%s: ncopen failed", pname);
return ++nerrs;
}
/* opened in data mode, try putting and getting hypercubes of each type.
* prints out messages for discrepancies */
nerrs += test_varputgetg (cdfid);
/* find a variable with at least one dimension */
iv = 0;
while (test.vars[iv].ndims <= 0 && iv < test.nvars)
iv++;
if (iv < test.nvars) { /* iv is first varid of var with dimensions */
/* set coords and strides */
for (id = 0; id < test.vars[iv].ndims; id++) {
hc.cor[id] = 0;
hc.edg[id] = 1;
strides[id] = 1;
}
/* fill in vals with value of appropriate type */
hc.vals = emalloc(nctypelen(test.vars[iv].type));
val_fill(test.vars[iv].type, 1, hc.vals);
# define TEST_FAILS(varid) \
(ncvarputg(cdfid, varid, hc.cor, hc.edg, \
strides, (long*)NULL, hc.vals) != -1)
id = test.vars[iv].ndims - 1;
tmp = hc.cor[id];
hc.cor[id] = -1; /* try negative coordinate, should fail */
if (TEST_FAILS(iv)) {
error("%s: ncvarputg should fail for negative corner", pname);
ncclose(cdfid); return ++nerrs;
}
hc.cor[id] = tmp;
tmp = hc.edg[id];
hc.edg[id] = -1; /* try negative edge, should fail */
if (TEST_FAILS(iv)) {
error("%s: ncvarputg should fail for negative edge", pname);
ncclose(cdfid); return ++nerrs;
}
hc.edg[id] = tmp;
tmp = hc.cor[id];
hc.cor[id] = test.dims[id].size; /* try big coordinate, should fail */
if (TEST_FAILS(iv)) {
error("%s: ncvarputg should fail for too-high coordinate", pname);
ncclose(cdfid); return ++nerrs;
}
hc.cor[id] = tmp;
tmp = hc.edg[id];
hc.edg[id] = test.dims[id].size + 1; /* try big edge, should fail */
if (TEST_FAILS(iv)) {
error("%s: ncvarputg should fail for too-high edge", pname);
ncclose(cdfid); return ++nerrs;
}
hc.edg[id] = tmp;
tmp = strides[id];
strides[id] = -1; /* try non-positive stride, * should fail */
if (TEST_FAILS(iv)) {
error("%s: ncvarputg should fail for non-positive stride", pname);
ncclose(cdfid); return ++nerrs;
}
strides[id] = tmp;
if (ncredef(cdfid) == -1) {
error("%s: ncredef failed", pname);
ncclose(cdfid); return ++nerrs;
}
/* try in define mode, should fail */
if (TEST_FAILS(iv)) {
error("%s: ncvarputg should fail in define mode", pname);
ncclose(cdfid); return ++nerrs;
}
if (ncendef (cdfid) == -1) {
error("%s: ncendef failed", pname);
ncclose(cdfid); return ++nerrs;
}
}
/* try with bad variable handle, should fail */
if (TEST_FAILS(-1)) {
error("%s: ncvarputg should fail for bad variable handle", pname);
ncclose(cdfid); return ++nerrs;
}
if (ncclose (cdfid) == -1) {
error("%s: ncclose failed", pname);
return ++nerrs;
}
/* try with bad netCDF handle, should fail */
if (TEST_FAILS(0)) {
error("%s: ncvarputg failed to report bad netcdf handle", pname);
nerrs++;
}
if(hc.vals != NULL) free (hc.vals);
if (nerrs > 0)
(void) fprintf(stderr,"FAILED! ***\n");
else
(void) fprintf(stderr,"ok ***\n");
return nerrs;
}
|
