atttests.c#49
    int cdfid;			/* netcdf id */
#81
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#86
    if (ncredef(cdfid) == -1) {
#88
	ncclose(cdfid); return ++nerrs;
#91
    if (ncinquire(cdfid, &ndims, &nvars, &ngatts, &xdimid) == -1) {
#93
	ncclose(cdfid); return ++nerrs;
#98
	if (ncattput(cdfid, NC_GLOBAL, atts[ia].name, atts[ia].type,
#101
	    ncclose(cdfid); return ++nerrs;
#106
    if (ncinquire(cdfid, &ndims, &nvars, &ngatts, &xdimid) == -1) {
#108
	ncclose(cdfid); return ++nerrs;
#117
	if (ncattinq(cdfid, NC_GLOBAL, atts[ia].name,
#120
	    ncclose(cdfid); return ++nerrs;
#125
	    ncclose(cdfid); return ++nerrs;
#129
	if (ncattget(cdfid, NC_GLOBAL, atts[ia].name, tmp.val) == -1) {
#131
	    ncclose(cdfid); return ++nerrs;
#144
    if ((ww_id = ncvardef(cdfid,
#147
	ncclose(cdfid); return ++nerrs;
#151
	if (ncattput(cdfid, ww_id,
#155
	    ncclose(cdfid); return ++nerrs;
#161
	if (ncattinq(cdfid, ww_id, atts[ia].name,
#164
	    ncclose(cdfid); return ++nerrs;
#169
	    ncclose(cdfid); return ++nerrs;
#173
	if (ncattget(cdfid, ww_id, atts[ia].name, tmp.val) == -1) {
#175
	    ncclose(cdfid); return ++nerrs;
#191
	if (ncattput(cdfid, ww_id, atts[ia-1].name, atts[ia].type,
#194
	    ncclose(cdfid); return ++nerrs;
#205
	if (ncattinq(cdfid, ww_id, atts[ia-1].name,
#208
	    ncclose(cdfid); return ++nerrs;
#213
	    ncclose(cdfid); return ++nerrs;
#217
	if (ncattget(cdfid, ww_id, atts[ia-1].name, tmp.val) == -1) {
#219
	    ncclose(cdfid); return ++nerrs;
#229
    if (ncattput(cdfid, ww_id, "bogus_att1", BAD_TYPE,
#235
    if (ncattput(cdfid, ww_id, "bogus_att2", atts[0].type,
#240
    if (ncendef (cdfid) == -1) {
#242
	ncclose(cdfid); return ++nerrs;
#245
    if (ncattput(cdfid, ww_id, atts[0].name, atts[0].type,
#251
	if (ncattput(cdfid, ww_id, atts[0].name, atts[0].type,
#258
    if (ncattput(cdfid, ww_id, "new_name", atts[0].type,
#262
	ncclose(cdfid); return ++nerrs;
#270
	if (ncattput(cdfid, ww_id, atts[ia+1].name, atts[ia].type,
#274
	    ncclose(cdfid); return ++nerrs;
#285
	if (ncattinq(cdfid, ww_id, atts[ia+1].name, &tmp.type, &tmp.len)
#289
	    ncclose(cdfid); return ++nerrs;
#294
	    ncclose(cdfid); return ++nerrs;
#298
	if (ncattget(cdfid, ww_id, atts[ia+1].name, tmp.val) == -1) {
#301
	    ncclose(cdfid); return ++nerrs;
#310
    if (ncattput(cdfid, test.nvars, atts[0].name, atts[0].type, atts[0].len,
#313
	ncclose(cdfid); return ++nerrs;
#315
    if (ncclose (cdfid) == -1) {
#320
    if (ncattput(cdfid, ww_id, atts[0].name, atts[0].type, atts[0].len,
#323
	ncclose(cdfid); return ++nerrs;
#349
    int cdfid;			/* netcdf id */
#359
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#365
	if (ncattinq(cdfid, test.atts[ia].var, test.atts[ia].name,
#368
	    ncclose(cdfid);
#373
	    ncclose(cdfid);
#378
	    ncclose(cdfid);
#384
    if (ncredef(cdfid) == -1) {
#386
	ncclose(cdfid); return ++nerrs;
#392
    if ((vv_id = ncvardef(cdfid, vv.name, vv.type, vv.ndims, vv.dims))
#395
	ncclose(cdfid); return ++nerrs;
#400
    if (ncattinq(cdfid, vv_id, "nonesuch", &type, &len) != -1) {
#402
	ncclose(cdfid); return ++nerrs;
#405
    if (ncattinq(cdfid, test.nvars, test.atts[0].name, &type, &len) != -1) {
#407
	ncclose(cdfid); return ++nerrs;
#411
	if (ncattinq(cdfid, test.atts[ia].var, test.atts[ia].name,
#414
	    ncclose(cdfid);
#419
	    ncclose(cdfid);
#424
	    ncclose(cdfid);
#428
    if (ncendef (cdfid) == -1) {
#430
	ncclose(cdfid); return ++nerrs;
#432
    if (ncclose (cdfid) == -1) {
#436
    if (ncattinq(cdfid, NC_GLOBAL, test.atts[0].name, &type, &len) != -1) {
#463
    int cdfid;			/* netcdf id */
#477
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#482
    if (ncredef(cdfid) == -1) {
#484
	ncclose(cdfid); return ++nerrs;
#490
    if ((uu_id = ncvardef(cdfid,
#493
	ncclose(cdfid); return ++nerrs;
#498
    if (ncattput(cdfid, uu_id,
#502
	ncclose(cdfid); return ++nerrs;
#508
	if (ncattinq(cdfid, test.atts[ia].var, test.atts[ia].name,
#511
	    ncclose(cdfid); return ++nerrs;
#515
	    ncclose(cdfid);
#520
	    ncclose(cdfid); return ++nerrs;
#524
	if (ncattget(cdfid, test.atts[ia].var, test.atts[ia].name, tmp.val)
#528
	    ncclose(cdfid); return ++nerrs;
#533
		  cdfid, test.vars[test.atts[ia].var].name,
#544
    if (ncendef (cdfid) == -1) {
#546
	ncclose(cdfid); return ++nerrs;
#551
	if (ncattinq(cdfid, test.atts[ia].var, test.atts[ia].name,
#554
	    ncclose(cdfid);
#559
	    ncclose(cdfid);
#564
	    ncclose(cdfid);
#569
	if (ncattget(cdfid, test.atts[ia].var, test.atts[ia].name, tmp.val)
#573
	    ncclose(cdfid); return ++nerrs;
#578
		  cdfid, test.vars[test.atts[ia].var].name,
#590
    if (ncattget(cdfid, test.nvars, vmax.name, vmax.val) != -1) {
#592
	ncclose(cdfid); return ++nerrs;
#595
    if (ncattget(cdfid, uu_id, "nonesuch", vmax.val) != -1) {
#597
	ncclose(cdfid); return ++nerrs;
#599
    if (ncclose (cdfid) == -1) {
#604
    if (ncattget(cdfid, uu_id, vmax.name, vmax.val) != -1) {
#606
	ncclose(cdfid); return ++nerrs;
#637
    int cdfid, cdfid2;		/* netcdf id */
#655
    if ((cdfid = ncopen(path1, NC_WRITE)) == -1) {
#660
    if (ncredef(cdfid) == -1) {
#662
	ncclose(cdfid); return ++nerrs;
#665
    if (ncattput(cdfid, NC_GLOBAL, att.name, att.type, att.len, att.val) == -1) {
#667
	ncclose(cdfid); return ++nerrs;
#673
    if ((tt_id=ncvardef(cdfid, tt.name, tt.type, tt.ndims, tt.dims)) == -1) {
#675
	ncclose(cdfid); return ++nerrs;
#678
    if (ncattput(cdfid, tt_id, att.name, att.type, att.len, att.val) == -1) {
#680
	ncclose(cdfid); return ++nerrs;
#687
    if ((tu_id=ncvardef(cdfid, tu.name, tu.type, tu.ndims, tu.dims)) == -1) {
#689
	ncclose(cdfid); return ++nerrs;
#692
    if (ncattput(cdfid, tu_id, att.name, att.type, att.len, att.val) == -1) {
#694
	ncclose(cdfid); return ++nerrs;
#697
    if (ncendef (cdfid) == -1) {
#699
	ncclose(cdfid); return ++nerrs;
#715
	    ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#720
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#723
    if (ncattcopy(cdfid, NC_GLOBAL, att.name, cdfid2, NC_GLOBAL) == -1) {
#726
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#731
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#735
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#741
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#750
    if (ncattcopy(cdfid, tt_id, att.name, cdfid2, tu2_id) == -1) {
#752
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#757
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#761
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#767
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#782
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#785
    if (ncattput(cdfid, NC_GLOBAL, att2.name, att2.type, att2.len, att2.val)
#788
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#792
    if (ncattcopy(cdfid, NC_GLOBAL, att2.name, cdfid2, tu2_id) == -1) {
#795
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#800
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#804
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#810
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#821
    if (ncattcopy(cdfid, NC_GLOBAL, att2.name, cdfid, tu_id) == -1) {
#823
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#827
    if (ncattinq(cdfid, tu_id, att2.name, &tmp.type, &tmp.len) == -1) {
#829
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#833
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#837
    if (ncattget(cdfid, tu_id, att2.name, tmp.val) == -1) {
#839
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#849
    if (ncattcopy(cdfid, tu_id, att.name, cdfid, tu_id) == -1) {
#852
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#855
    if (ncattcopy(cdfid, tt_id, "nonesuch", cdfid, tu_id) != -1) {
#858
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#861
    if (ncattcopy(cdfid, test.nvars, att.name, cdfid, tu_id) != -1) {
#864
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#866
    if (ncattcopy(cdfid, tt_id, att.name, cdfid, 2) != -1) {
#869
	ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#873
	ncclose(cdfid); return ++nerrs;
#876
    if (ncattcopy(cdfid, tt_id, att.name, cdfid2, tu_id) != -1) {
#879
	ncclose(cdfid); return ++nerrs;
#881
    if (ncclose (cdfid) == -1) {
#885
    if (ncattcopy(cdfid, tt_id, att.name, cdfid2, tu_id) != -1) {
#916
    int cdfid;			/* netcdf id */
#926
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#931
    if (ncredef(cdfid) == -1) {
#933
	ncclose(cdfid); return ++nerrs;
#939
	if (ncattname(cdfid, NC_GLOBAL, ia, att.name) == -1) {
#941
	    ncclose(cdfid); return ++nerrs;
#949
	    ncclose(cdfid); return ++nerrs;
#962
	    if (ncattname(cdfid, iv, ia, att.name) == -1) {
#964
		ncclose(cdfid); return ++nerrs;
#972
		ncclose(cdfid); return ++nerrs;
#984
    if (ncattput(cdfid, NC_GLOBAL, att.name, att.type, att.len, att.val)
#987
	ncclose(cdfid); return ++nerrs;
#992
    if (ncattname(cdfid, NC_GLOBAL, test.ngatts-1, tmp.name) == -1) {
#994
	ncclose(cdfid); return ++nerrs;
#1001
    if (ncendef (cdfid) == -1) {
#1003
	ncclose(cdfid); return ++nerrs;
#1009
	if (ncattname(cdfid, NC_GLOBAL, ia, att.name) == -1) {
#1011
	    ncclose(cdfid); return ++nerrs;
#1019
	    ncclose(cdfid); return ++nerrs;
#1032
	    if (ncattname(cdfid, iv, ia, att.name) == -1) {
#1034
		ncclose(cdfid); return ++nerrs;
#1042
		ncclose(cdfid); return ++nerrs;
#1053
    if (ncattname(cdfid, test.nvars, 0, att.name) != -1) {
#1055
	ncclose(cdfid); return ++nerrs;
#1058
    if (ncattname(cdfid, NC_GLOBAL, -1, att.name) != -1) {
#1060
	ncclose(cdfid); return ++nerrs;
#1062
    if (ncattname(cdfid, NC_GLOBAL, test.ngatts, att.name) != -1) {
#1064
	ncclose(cdfid); return ++nerrs;
#1066
    if (ncclose (cdfid) == -1) {
#1072
    if (ncattname(cdfid, NC_GLOBAL, 0, att.name) != -1) {
#1102
    int cdfid;			/* netcdf id */
#1115
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#1120
    if (ncredef(cdfid) == -1) {
#1122
	ncclose(cdfid); return ++nerrs;
#1125
    if (ncattput(cdfid, NC_GLOBAL, atty.name, atty.type, atty.len,
#1128
	ncclose(cdfid); return ++nerrs;
#1132
    if (ncattput(cdfid, NC_GLOBAL, attz.name, attz.type, attz.len,
#1135
	ncclose(cdfid); return ++nerrs;
#1140
    if (ncattrename(cdfid, NC_GLOBAL, atty.name, newname) == -1) {
#1142
	ncclose(cdfid); return ++nerrs;
#1146
    if (ncattinq(cdfid, NC_GLOBAL, newname, &tmp.type, &tmp.len) == -1) {
#1148
	ncclose(cdfid); return ++nerrs;
#1152
	ncclose(cdfid); return ++nerrs;
#1156
    if (ncattget(cdfid, NC_GLOBAL, newname, tmp.val) == -1) {
#1158
	ncclose(cdfid); return ++nerrs;
#1165
    if (ncattinq(cdfid, NC_GLOBAL, atty.name, &tmp.type, &tmp.len) != -1) {
#1167
	ncclose(cdfid); return ++nerrs;
#1170
    if (ncattrename(cdfid, NC_GLOBAL, attz.name, newname) != -1) {
#1172
	ncclose(cdfid); return ++nerrs;
#1175
    if (ncattrename(cdfid, NC_GLOBAL, attz.name, longername) == -1) {
#1177
	ncclose(cdfid); return ++nerrs;
#1180
    if (ncattrename(cdfid, test.nvars, newname, atty.name) != -1) {
#1182
	ncclose(cdfid); return ++nerrs;
#1185
    if (ncattrename(cdfid, NC_GLOBAL, "nonesuch", newname) != -1) {
#1188
	ncclose(cdfid); return ++nerrs;
#1190
    if (ncendef (cdfid) == -1) {
#1192
	ncclose(cdfid); return ++nerrs;
#1195
    if (ncattrename(cdfid, NC_GLOBAL, newname, "short") == -1) {
#1197
	ncclose(cdfid); return ++nerrs;
#1199
    if (ncattrename(cdfid, NC_GLOBAL, "short", "plugh") == -1) {
#1201
	ncclose(cdfid); return ++nerrs;
#1203
    if (ncattget(cdfid, NC_GLOBAL, "plugh", tmp.val) == -1) {
#1205
	ncclose(cdfid); return ++nerrs;
#1213
    if (ncclose (cdfid) == -1) {
#1218
    if (ncattrename(cdfid, NC_GLOBAL, newname, atty.name) != -1) {
#1220
	ncclose(cdfid); return ++nerrs;
#1245
    int cdfid;			/* netcdf id */
#1264
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#1269
    if (ncredef(cdfid) == -1) {
#1271
	ncclose(cdfid); return ++nerrs;
#1274
    if (ncattput(cdfid, NC_GLOBAL, yaa.name, yaa.type, yaa.len, yaa.val) == -1) {
#1276
	ncclose(cdfid); return ++nerrs;
#1282
    if ((yav_id=ncvardef(cdfid, yav.name, yav.type, yav.ndims, yav.dims))
#1285
	ncclose(cdfid); return ++nerrs;
#1288
    if (ncattput(cdfid, yav_id, yaa.name, yaa.type, yaa.len, yaa.val) == -1) {
#1290
	ncclose(cdfid); return ++nerrs;
#1295
    if (ncinquire(cdfid, &ndims, &nvars, &ngatts1, &xdimid) == -1) {
#1297
	ncclose(cdfid); return ++nerrs;
#1301
    if (ncvarinq(cdfid, yav_id, vtmp.name, &vtmp.type, &vtmp.ndims, vtmp.dims,
#1304
	ncclose(cdfid); return ++nerrs;
#1308
    if (ncattdel(cdfid, NC_GLOBAL, yaa.name) == -1) {
#1310
	ncclose(cdfid); return ++nerrs;
#1313
    if (ncinquire(cdfid, &ndims, &nvars, &ngatts2, &xdimid) == -1) {
#1315
	ncclose(cdfid); return ++nerrs;
#1320
	ncclose(cdfid); return ++nerrs;
#1322
    if (ncattinq(cdfid, NC_GLOBAL, yaa.name, &atmp.type, &atmp.len) != -1) {
#1324
	ncclose(cdfid); return ++nerrs;
#1328
    if (ncattdel(cdfid, yav_id, yaa.name) == -1) {
#1330
	ncclose(cdfid); return ++nerrs;
#1333
    if (ncvarinq(cdfid, yav_id, vtmp.name, &vtmp.type, &vtmp.ndims,
#1336
	ncclose(cdfid); return ++nerrs;
#1341
	ncclose(cdfid); return ++nerrs;
#1343
    if (ncattinq(cdfid, yav_id, yaa.name, &atmp.type, &atmp.len) != -1) {
#1346
	ncclose(cdfid); return ++nerrs;
#1349
    if (ncattput(cdfid, NC_GLOBAL, yaa.name, yaa.type, yaa.len, yaa.val) == -1) {
#1351
	ncclose(cdfid); return ++nerrs;
#1354
    if (ncattput(cdfid, yav_id, yaa.name, yaa.type, yaa.len, yaa.val) == -1) {
#1356
	ncclose(cdfid); return ++nerrs;
#1360
    if (ncattdel(cdfid, yav_id, "nonesuch") != -1) {
#1362
	ncclose(cdfid); return ++nerrs;
#1365
    if (ncattdel(cdfid, test.nvars, yaa.name) != -1) {
#1367
	ncclose(cdfid); return ++nerrs;
#1369
    if (ncendef (cdfid) == -1) {
#1371
	ncclose(cdfid); return ++nerrs;
#1374
    if (ncattdel(cdfid, NC_GLOBAL, yaa.name) != -1) {
#1376
	ncclose(cdfid); return ++nerrs;
#1378
    if (ncclose (cdfid) == -1) {
#1383
    if (ncattdel(cdfid, yav_id, yaa.name) != -1) {
dimtests.c#33
    int cdfid;			/* netcdf id */
#48
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#53
    if (ncdimdef(cdfid, mm.name, mm.size) != -1) {
#55
	ncclose(cdfid); return ++nerrs;
#58
    if (ncredef(cdfid) == -1) {
#60
	ncclose(cdfid); return ++nerrs;
#63
    if ((dimid = ncdimdef(cdfid, mm.name, mm.size)) == -1) {
#65
	ncclose(cdfid); return ++nerrs;
#72
	ncclose(cdfid); return ++nerrs;
#76
    if (ncdimdef(cdfid, mm.name, mm.size) != -1) {
#78
	ncclose(cdfid); return ++nerrs;
#81
    if (ncdimdef(cdfid, nn.name, (long) -10) != -1) {
#83
	ncclose(cdfid); return ++nerrs;
#86
    if (ncinquire(cdfid, &ndims, &nvars, &natts, &xdimid) == -1) {
#88
	ncclose(cdfid); return ++nerrs;
#91
	if (ncdimdef(cdfid, rec.name, rec.size) == -1) {
#93
	    ncclose(cdfid); return ++nerrs;
#98
    if (ncdimdef(cdfid, "rec2", rec.size) != -1) {
#101
	ncclose(cdfid); return ++nerrs;
#103
    if (ncendef (cdfid) == -1) {
#105
	ncclose(cdfid); return ++nerrs;
#107
    if (ncclose (cdfid) == -1) {
#111
    if (ncdimdef(cdfid, "rec2", rec.size) != -1) {
#137
    int cdfid;			/* netcdf id */
#144
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#149
    if (ncredef(cdfid) == -1) {
#151
	ncclose(cdfid); return ++nerrs;
#154
    if ((nn_dim = ncdimdef(cdfid, nn.name, nn.size)) == -1) {
#156
	ncclose(cdfid); return ++nerrs;
#160
    if (ncdimid(cdfid, nn.name) != nn_dim) {
#162
	ncclose(cdfid); return ++nerrs;
#164
    if (ncendef (cdfid) == -1) {
#166
	ncclose(cdfid); return ++nerrs;
#169
    if (ncdimid(cdfid, nn.name) != nn_dim) {
#171
	ncclose(cdfid); return ++nerrs;
#174
    if (ncdimid(cdfid, "easter-bunny") != -1) {
#176
	ncclose(cdfid); return ++nerrs;
#179
    if (ncdimid(cdfid, "rec") != test.xdimid) {
#181
	ncclose(cdfid); return ++nerrs;
#183
    if (ncclose (cdfid) == -1) {
#188
    if (ncdimid(cdfid, nn.name) != -1) {
#214
    int cdfid;			/* netcdf id */
#220
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#227
	if (ncdiminq(cdfid, dimid, dim.name, &dim.size) == -1) {
#230
	    ncclose(cdfid); return ++nerrs;
#244
    if (ncredef(cdfid) == -1) {
#246
	ncclose(cdfid); return ++nerrs;
#250
	if (ncdiminq(cdfid, dimid, dim.name, &dim.size) == -1) {
#253
	    ncclose(cdfid); return ++nerrs;
#268
    if (ncdiminq(cdfid, -1, dim.name, &dim.size) != -1 ||
#269
	ncdiminq(cdfid, test.ndims, dim.name, &dim.size) != -1) {
#272
	ncclose(cdfid); return ++nerrs;
#274
    if (ncendef (cdfid) == -1) {
#276
	ncclose(cdfid); return ++nerrs;
#278
    if (ncclose (cdfid) == -1) {
#284
	if (ncdiminq (cdfid, 0, dim.name, &dim.size) != -1) {
#311
    int cdfid;			/* netcdf id */
#323
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#328
    if (ncredef(cdfid) == -1) {
#330
	ncclose(cdfid); return ++nerrs;
#333
    if ((pp_dim = ncdimdef(cdfid, pp.name, pp.size)) == -1) {
#335
	ncclose(cdfid); return ++nerrs;
#338
    if (ncdimdef(cdfid, qq.name, qq.size) == -1) {
#340
	ncclose(cdfid); return ++nerrs;
#344
    if (ncdimrename(cdfid, pp_dim, newname) == -1) {
#346
	ncclose(cdfid); return ++nerrs;
#350
    if (ncdiminq(cdfid, pp_dim, dim.name, &dim.size) == -1) {
#352
	ncclose(cdfid); return ++nerrs;
#356
	ncclose(cdfid); return ++nerrs;
#361
	ncclose(cdfid); return ++nerrs;
#367
    if (ncdimrename(cdfid, pp_dim, qq.name) != -1) {
#369
	ncclose(cdfid); return ++nerrs;
#372
    if (ncdimrename(cdfid, -1, dim.name) != -1 ||
#373
	ncdimrename(cdfid, test.ndims, dim.name) != -1) {
#376
	ncclose(cdfid); return ++nerrs;
#378
    if (ncendef (cdfid) == -1) {
#380
	ncclose(cdfid); return ++nerrs;
#384
    if (ncdimrename(cdfid, pp_dim, "p") == -1) {
#386
	ncclose(cdfid); return ++nerrs;
#392
    if (pp_dim != ncdimid(cdfid, "p")) {
#398
    if (ncdimrename(cdfid, pp_dim, pp.name) == -1) {
#400
	ncclose(cdfid); return ++nerrs;
#405
    if (ncclose (cdfid) == -1) {
#410
    if (ncdimrename (cdfid, 0, dim.name) != -1) {
slabs.c#112
test_slabs(cdfid)
#113
     int cdfid;			/* handle of netcdf open and in data mode */
#140
    if (ncredef(cdfid) == -1) {
#142
	ncclose(cdfid); return 1;
#148
	dimids[idim] = ncdimdef(cdfid, dims[idim].name, dims[idim].size);
#151
	    ncclose(cdfid);
#163
	varid[iv] = ncvardef(cdfid, va[iv].name, va[iv].type, va[iv].ndims,
#167
	    ncclose(cdfid); return 1;
#173
    if (ncendef (cdfid) == -1) {
#175
	ncclose(cdfid); return 1;
#206
	if (ncvarput(cdfid, varid[iv], corner, edge, (void *) v) == -1) {
#223
	if (ncvarget(cdfid, varid[iv], corner, edge, (void *) v) == -1) {
#242
	    if (ncvarget(cdfid, varid[iv], corner, edge, (void *) v) == -1) {
#268
		if (ncvarget(cdfid, varid[iv], corner, edge, (void *) v) == -1) {
#307
		    if (ncvarget(cdfid, varid[iv], corner, edge, (void *) v) == -1) {
t_nc.c#108
createtestdims(int cdfid, size_t num_dims, const size_t *sizes, const char * const dim_names[])
#113
		assert( nc_def_dim(cdfid, *dim_names++, *sizes, &dimid)
#122
testdims(int cdfid, size_t num_dims, size_t *sizes, const char * const dim_names[])
#129
		assert( nc_inq_dim(cdfid, ii, cp, &size) == NC_NOERR);
vardef.c#112
    int cdfid;			/* netcdf id */
#137
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#142
    if (ncvardef(cdfid, va[0].name, va[0].type, va[0].ndims, va[0].dims)
#145
	ncclose(cdfid); return ++nerrs;
#148
    if (ncredef(cdfid) == -1) {
#150
	ncclose(cdfid); return ++nerrs;
#155
	if ((di_id[id] = ncdimdef(cdfid, di[id].name, di[id].size)) == -1) {
#158
	    ncclose(cdfid); return ++nerrs;
#172
	if ((va_id[iv] = ncvardef(cdfid, va[iv].name, va[iv].type,
#176
	    ncclose(cdfid); return ++nerrs;
#183
	    ncclose(cdfid); return ++nerrs;
#186
	if (ncvarinq(cdfid, va_id[iv], tmp.name, &tmp.type,
#190
	    ncclose(cdfid); return ++nerrs;
#213
    if (ncvardef(cdfid, va[0].name, va[0].type,
#216
	ncclose(cdfid); return ++nerrs;
#219
    if (ncvardef(cdfid, "badtype", BAD_TYPE, va[0].ndims, va[0].dims) != -1) {
#221
	ncclose(cdfid); return ++nerrs;
#224
    if (ncvardef(cdfid, "badndims", va[0].type, -1, va[0].dims) != -1) {
#226
	ncclose(cdfid); return ++nerrs;
#230
    if (ncvardef(cdfid, "baddims", va[0].type, va[0].ndims, va[0].dims)
#234
	ncclose(cdfid); return ++nerrs;
#236
    if (ncendef (cdfid) == -1) {
#238
	ncclose(cdfid); return ++nerrs;
#249
		if (ncvarget1(cdfid, va_id[iv], where, (void *) &val) != -1) {
#263
		if (ncvarget1(cdfid, va_id[iv], where, (void *) &val) != -1) {
#277
		if (ncvarget1(cdfid, va_id[iv], where, (void *) &val) != -1) {
#291
		if (ncvarget1(cdfid, va_id[iv], where, (void *) &val) != -1) {
#306
		if (ncvarget1(cdfid, va_id[iv], where, (void *) &val) != -1) {
#320
		if (ncvarget1(cdfid, va_id[iv], where, (void *) &val) != -1) {
#337
    if (ncclose (cdfid) == -1) {
varget.c#32
    int cdfid;			/* netcdf id */
#42
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#47
    nerrs += test_varputget (cdfid);
#50
    nerrs += test_slabs (cdfid);
#70
	if(ncvarget (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#72
	    ncclose(cdfid); return ++nerrs;
#77
	if(ncvarget (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#79
	    ncclose(cdfid); return ++nerrs;
#89
	if(ncvarget (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#91
	    ncclose(cdfid); return ++nerrs;
#96
	if(ncvarget (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#98
	    ncclose(cdfid); return ++nerrs;
#103
	if (ncredef(cdfid) == -1) {
#105
	    ncclose(cdfid); return ++nerrs;
#108
	if(ncvarget (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#111
	    ncclose(cdfid); return ++nerrs;
#113
	if (ncendef (cdfid) == -1) {
#115
	    ncclose(cdfid); return ++nerrs;
#119
    if(ncvarget (cdfid, -1, hc.cor, hc.edg, hc.vals) != -1) {
#121
	ncclose(cdfid); return ++nerrs;
#123
    if (ncclose (cdfid) == -1) {
#128
    if(ncvarget (cdfid, 0, hc.cor, hc.edg, hc.vals) != -1) {
vargetg.c#33
    int cdfid;			/* netcdf id */
#44
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#49
    nerrs += test_varputgetg (cdfid);
#70
	    (ncvarputg(cdfid, varid, hc.cor, hc.edg, \
#78
	    ncclose(cdfid); return ++nerrs;
#85
	    ncclose(cdfid); return ++nerrs;
#92
	    ncclose(cdfid); return ++nerrs;
#99
	    ncclose(cdfid); return ++nerrs;
#106
	    ncclose(cdfid); return ++nerrs;
#110
	if (ncredef(cdfid) == -1) {
#112
	    ncclose(cdfid); return ++nerrs;
#118
	    ncclose(cdfid); return ++nerrs;
#120
	if (ncendef (cdfid) == -1) {
#122
	    ncclose(cdfid); return ++nerrs;
#128
	ncclose(cdfid); return ++nerrs;
#130
    if (ncclose (cdfid) == -1) {
varput.c#33
    int cdfid;			/* netcdf id */
#50
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#56
    nerrs += test_varputget (cdfid);	/* prints messages for discrepencies */
#75
	if(ncvarput (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#77
	    ncclose(cdfid); return ++nerrs;
#82
	if(ncvarput (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#84
	    ncclose(cdfid); return ++nerrs;
#93
		if(ncvarput (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#95
		    ncclose(cdfid); return ++nerrs;
#101
		if(ncvarput (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#103
		    ncclose(cdfid); return ++nerrs;
#108
	if (ncredef(cdfid) == -1) {
#110
	    ncclose(cdfid); return ++nerrs;
#113
	if(ncvarput (cdfid, iv, hc.cor, hc.edg, hc.vals) != -1) {
#115
	    ncclose(cdfid); return ++nerrs;
#117
	if (ncendef (cdfid) == -1) {
#119
	    ncclose(cdfid); return ++nerrs;
#125
    if(ncvarput (cdfid, -1, hc.cor, hc.edg, hc.vals) != -1) {
#127
	ncclose(cdfid); return ++nerrs;
#129
    if (ncclose (cdfid) == -1) {
#134
    if(ncvarput (cdfid, 0, hc.cor, hc.edg, hc.vals) != -1) {
varputg.c#33
    int cdfid;			/* netcdf id */
#46
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#53
    nerrs += test_varputgetg (cdfid);
#73
	    (ncvarputg(cdfid, varid, hc.cor, hc.edg, \
#81
	    ncclose(cdfid); return ++nerrs;
#88
	    ncclose(cdfid); return ++nerrs;
#95
	    ncclose(cdfid); return ++nerrs;
#102
	    ncclose(cdfid); return ++nerrs;
#109
	    ncclose(cdfid); return ++nerrs;
#113
	if (ncredef(cdfid) == -1) {
#115
	    ncclose(cdfid); return ++nerrs;
#120
	    ncclose(cdfid); return ++nerrs;
#122
	if (ncendef (cdfid) == -1) {
#124
	    ncclose(cdfid); return ++nerrs;
#130
	ncclose(cdfid); return ++nerrs;
#132
    if (ncclose (cdfid) == -1) {
vartests.c#32
    int cdfid;			/* netcdf id */
#41
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#46
    if (ncredef(cdfid) == -1) {
#48
	ncclose(cdfid); return ++nerrs;
#54
    if ((varid = ncvardef(cdfid,
#57
	ncclose(cdfid); return ++nerrs;
#62
    if (ncvarid(cdfid, xx.name) != varid) {
#64
	ncclose(cdfid); return ++nerrs;
#66
    if (ncendef (cdfid) == -1) {
#68
	ncclose(cdfid); return ++nerrs;
#71
    if (ncvarid(cdfid, xx.name) != varid) {
#73
	ncclose(cdfid); return ++nerrs;
#76
    if (ncvarid(cdfid, "santa-claus") != -1) {
#78
	ncclose(cdfid); return ++nerrs;
#80
    if (ncclose (cdfid) == -1) {
#85
    if (ncvarid(cdfid, xx.name) != -1) {
#112
    int cdfid;			/* netcdf id */
#119
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#127
	if (ncvarinq(cdfid, varid, var.name, &var.type,
#131
	    ncclose(cdfid); return ++nerrs;
#159
    if (ncredef(cdfid) == -1) {
#161
	ncclose(cdfid); return ++nerrs;
#165
	if (ncvarinq(cdfid, varid, var.name, &var.type,
#169
	    ncclose(cdfid); return ++nerrs;
#197
    if (ncvarinq(cdfid, -1, var.name, &var.type,
#199
	ncvarinq(cdfid, test.nvars, var.name, &var.type,
#203
	ncclose(cdfid); return ++nerrs;
#205
    if (ncendef (cdfid) == -1) {
#207
	ncclose(cdfid); return ++nerrs;
#209
    if (ncclose (cdfid) == -1) {
#215
	if (ncvarinq(cdfid, varid, var.name, &var.type,
#252
test_varputget1(cdfid)
#253
     int cdfid;			/* handle of netcdf open and in data mode */
#314
	    if(ncvarput1 (cdfid, iv, elm[ie].coords, voidp) == -1) {
#317
		ncclose(cdfid); return 1;
#321
	    if(ncvarget1 (cdfid, iv, elm[ie].coords, tmpp) == -1) {
#324
		ncclose(cdfid); return 1;
#388
    int cdfid;			/* netcdf id */
#394
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#399
    nerrs += test_varputget1 (cdfid);	/* tests ncvarput1 and ncvarget1 */
#412
	if(ncvarput1 (cdfid, iv, elm.coords, (void *) &elm.val) != -1) {
#414
	    ncclose(cdfid); return ++nerrs;
#418
	if(ncvarput1 (cdfid, iv, elm.coords, (void *) &elm.val) != -1) {
#420
	    ncclose(cdfid); return ++nerrs;
#424
    if(ncvarput1 (cdfid, -1, elm.coords, (void *) &elm.val) != -1 ||
#425
       ncvarput1 (cdfid, test.nvars, elm.coords, (void *) &elm.val) != -1) {
#427
	ncclose(cdfid); return ++nerrs;
#429
    if (ncredef(cdfid) == -1) {
#431
	ncclose(cdfid); return ++nerrs;
#435
      if(ncvarput1 (cdfid, 0, elm.coords, (void *) &elm.val) != -1) {
#437
	  ncclose(cdfid); return ++nerrs;
#439
    if (ncendef (cdfid) == -1) {
#441
	ncclose(cdfid); return ++nerrs;
#443
    if (ncclose (cdfid) == -1) {
#448
    if(ncvarput1 (cdfid, 0, elm.coords, (void *) &elm.val) != -1) {
#476
    int cdfid;			/* netcdf id */
#482
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#487
    nerrs += test_varputget1 (cdfid);	/* tests ncvarput1 and ncvarget1 */
#500
	if(ncvarget1 (cdfid, iv, elm.coords, (void *) &elm.val) != -1) {
#502
	    ncclose(cdfid); return ++nerrs;
#506
	if(ncvarget1 (cdfid, iv, elm.coords, (void *) &elm.val) != -1) {
#508
	    ncclose(cdfid); return ++nerrs;
#512
    if(ncvarget1 (cdfid, -1, elm.coords, (void *) &elm.val) != -1 ||
#513
       ncvarget1 (cdfid, test.nvars, elm.coords, (void *) &elm.val) != -1) {
#515
	ncclose(cdfid); return ++nerrs;
#517
    if (ncredef(cdfid) == -1) {
#519
	ncclose(cdfid); return ++nerrs;
#523
      if(ncvarget1 (cdfid, 0, elm.coords, (void *) &elm.val) != -1) {
#526
	  ncclose(cdfid); return ++nerrs;
#528
    if (ncendef (cdfid) == -1) {
#530
	ncclose(cdfid); return ++nerrs;
#532
    if (ncclose (cdfid) == -1) {
#537
    if(ncvarget1 (cdfid, 0, elm.coords, (void *) &elm.val) != -1) {
#564
    int cdfid;			/* netcdf id */
#577
    if ((cdfid = ncopen(path, NC_WRITE)) == -1) {
#582
    if (ncredef(cdfid) == -1) {
#584
	ncclose(cdfid); return ++nerrs;
#590
    if ((yy_id = ncvardef(cdfid,
#593
	ncclose(cdfid); return ++nerrs;
#599
    if (ncvardef(cdfid, zz.name, zz.type, zz.ndims, zz.dims) == -1) {
#601
	ncclose(cdfid); return ++nerrs;
#606
    if (ncvarrename(cdfid, yy_id, newname) == -1) {
#608
	ncclose(cdfid); return ++nerrs;
#611
    if (yy_id != ncvarid(cdfid, newname)) {
#616
    if (ncvarinq(cdfid, yy_id, var.name,
#619
	ncclose(cdfid); return ++nerrs;
#623
	ncclose(cdfid); return ++nerrs;
#628
	ncclose(cdfid); return ++nerrs;
#632
    if (ncvarrename(cdfid, yy_id, zz.name) != -1) {
#634
	ncclose(cdfid); return ++nerrs;
#637
    if (ncvarrename(cdfid, -1, var.name) != -1 ||
#638
	ncvarrename(cdfid, test.nvars, var.name) != -1) {
#641
	ncclose(cdfid); return ++nerrs;
#643
    if (ncendef (cdfid) == -1) {
#645
	ncclose(cdfid); return ++nerrs;
#648
    if (ncvarrename(cdfid, yy_id, "a_longer_name") != -1) {
#650
	ncclose(cdfid); return ++nerrs;
#652
    if (ncvarrename(cdfid, yy_id, shortname) == -1) {
#654
	ncclose(cdfid); return ++nerrs;
#658
    if (yy_id != ncvarid(cdfid, shortname)) {
#662
    if (ncclose (cdfid) == -1) {
#667
    if (ncvarrename (cdfid, 0, var.name) != -1) {
vputget.c#37
test_varputget(cdfid)
#38
     int cdfid;			/* handle of netcdf open and in data mode */
#86
		if(ncvarput (cdfid, iv, hc[ie].cor, hc[ie].edg, hc[ie].vals)
#105
		    if(ncvarget (cdfid, iv, hc[ie].cor, hc[ie].edg, tmp.vals)
vputgetg.c#37
test_varputgetg(cdfid)
#38
     int cdfid;			/* handle of netcdf open and in data mode */
#120
	    if(ncvarputg (cdfid, iv, hc[ie].cor, hc[ie].npts,
#155
		if(ncvargetg (cdfid, iv, hc[ie].cor, hc[ie].npts,

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