atttests.c#49    int cdfid; /* netcdf id */
#81    if ((cdfid = ncopen(pathNC_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(cdfidNC_GLOBALatts[ia].nameatts[ia].type,
#101     ncclose(cdfid); return ++nerrs;
#106    if (ncinquire(cdfid, &ndims, &nvars, &ngatts, &xdimid) == -1) {
#108 ncclose(cdfid); return ++nerrs;
#117 if (ncattinq(cdfidNC_GLOBALatts[ia].name,
#120     ncclose(cdfid); return ++nerrs;
#125     ncclose(cdfid); return ++nerrs;
#129 if (ncattget(cdfidNC_GLOBALatts[ia].nametmp.val) == -1) {
#131     ncclose(cdfid); return ++nerrs;
#144    if ((ww_id = ncvardef(cdfid,
#147 ncclose(cdfid); return ++nerrs;
#151 if (ncattput(cdfidww_id,
#155     ncclose(cdfid); return ++nerrs;
#161 if (ncattinq(cdfidww_idatts[ia].name,
#164     ncclose(cdfid); return ++nerrs;
#169     ncclose(cdfid); return ++nerrs;
#173 if (ncattget(cdfidww_idatts[ia].nametmp.val) == -1) {
#175     ncclose(cdfid); return ++nerrs;
#191 if (ncattput(cdfidww_idatts[ia-1].nameatts[ia].type,
#194     ncclose(cdfid); return ++nerrs;
#205 if (ncattinq(cdfidww_idatts[ia-1].name,
#208     ncclose(cdfid); return ++nerrs;
#213     ncclose(cdfid); return ++nerrs;
#217 if (ncattget(cdfidww_idatts[ia-1].nametmp.val) == -1) {
#219     ncclose(cdfid); return ++nerrs;
#229    if (ncattput(cdfidww_id, "bogus_att1", BAD_TYPE,
#235    if (ncattput(cdfidww_id, "bogus_att2", atts[0].type,
#240    if (ncendef (cdfid) == -1) {
#242 ncclose(cdfid); return ++nerrs;
#245    if (ncattput(cdfidww_idatts[0].nameatts[0].type,
#251 if (ncattput(cdfidww_idatts[0].nameatts[0].type,
#258    if (ncattput(cdfidww_id, "new_name", atts[0].type,
#262 ncclose(cdfid); return ++nerrs;
#270 if (ncattput(cdfidww_idatts[ia+1].nameatts[ia].type,
#274     ncclose(cdfid); return ++nerrs;
#285 if (ncattinq(cdfidww_idatts[ia+1].name, &tmp.type, &tmp.len)
#289     ncclose(cdfid); return ++nerrs;
#294     ncclose(cdfid); return ++nerrs;
#298 if (ncattget(cdfidww_idatts[ia+1].nametmp.val) == -1) {
#301     ncclose(cdfid); return ++nerrs;
#310    if (ncattput(cdfidtest.nvarsatts[0].nameatts[0].typeatts[0].len,
#313 ncclose(cdfid); return ++nerrs;
#315    if (ncclose (cdfid) == -1) {
#320    if (ncattput(cdfidww_idatts[0].nameatts[0].typeatts[0].len,
#323 ncclose(cdfid); return ++nerrs;
#349    int cdfid; /* netcdf id */
#359    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#365 if (ncattinq(cdfidtest.atts[ia].vartest.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(cdfidvv.namevv.typevv.ndimsvv.dims))
#395 ncclose(cdfid); return ++nerrs;
#400    if (ncattinq(cdfidvv_id, "nonesuch", &type, &len) != -1) {
#402 ncclose(cdfid); return ++nerrs;
#405    if (ncattinq(cdfidtest.nvarstest.atts[0].name, &type, &len) != -1) {
#407 ncclose(cdfid); return ++nerrs;
#411 if (ncattinq(cdfidtest.atts[ia].vartest.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(cdfidNC_GLOBALtest.atts[0].name, &type, &len) != -1) {
#463    int cdfid; /* netcdf id */
#477    if ((cdfid = ncopen(pathNC_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(cdfiduu_id,
#502 ncclose(cdfid); return ++nerrs;
#508 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#511     ncclose(cdfid); return ++nerrs;
#515     ncclose(cdfid);
#520     ncclose(cdfid); return ++nerrs;
#524 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#528     ncclose(cdfid); return ++nerrs;
#533   cdfidtest.vars[test.atts[ia].var].name,
#544    if (ncendef (cdfid) == -1) {
#546 ncclose(cdfid); return ++nerrs;
#551 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#554     ncclose(cdfid);
#559     ncclose(cdfid);
#564     ncclose(cdfid);
#569 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#573     ncclose(cdfid); return ++nerrs;
#578   cdfidtest.vars[test.atts[ia].var].name,
#590    if (ncattget(cdfidtest.nvarsvmax.namevmax.val) != -1) {
#592 ncclose(cdfid); return ++nerrs;
#595    if (ncattget(cdfiduu_id, "nonesuch", vmax.val) != -1) {
#597 ncclose(cdfid); return ++nerrs;
#599    if (ncclose (cdfid) == -1) {
#604    if (ncattget(cdfiduu_idvmax.namevmax.val) != -1) {
#606 ncclose(cdfid); return ++nerrs;
#637    int cdfidcdfid2; /* netcdf id */
#655    if ((cdfid = ncopen(path1NC_WRITE)) == -1) {
#660    if (ncredef(cdfid) == -1) {
#662 ncclose(cdfid); return ++nerrs;
#665    if (ncattput(cdfidNC_GLOBALatt.nameatt.typeatt.lenatt.val) == -1) {
#667 ncclose(cdfid); return ++nerrs;
#673    if ((tt_id=ncvardef(cdfidtt.namett.typett.ndimstt.dims)) == -1) {
#675 ncclose(cdfid); return ++nerrs;
#678    if (ncattput(cdfidtt_idatt.nameatt.typeatt.lenatt.val) == -1) {
#680 ncclose(cdfid); return ++nerrs;
#687    if ((tu_id=ncvardef(cdfidtu.nametu.typetu.ndimstu.dims)) == -1) {
#689 ncclose(cdfid); return ++nerrs;
#692    if (ncattput(cdfidtu_idatt.nameatt.typeatt.lenatt.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(cdfidNC_GLOBALatt.namecdfid2NC_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(cdfidtt_idatt.namecdfid2tu2_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(cdfidNC_GLOBALatt2.nameatt2.typeatt2.lenatt2.val)
#788 ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#792    if (ncattcopy(cdfidNC_GLOBALatt2.namecdfid2tu2_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(cdfidNC_GLOBALatt2.namecdfidtu_id) == -1) {
#823 ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#827    if (ncattinq(cdfidtu_idatt2.name, &tmp.type, &tmp.len) == -1) {
#829 ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#833 ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#837    if (ncattget(cdfidtu_idatt2.nametmp.val) == -1) {
#839 ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#849    if (ncattcopy(cdfidtu_idatt.namecdfidtu_id) == -1) {
#852 ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#855    if (ncattcopy(cdfidtt_id, "nonesuch", cdfidtu_id) != -1) {
#858 ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#861    if (ncattcopy(cdfidtest.nvarsatt.namecdfidtu_id) != -1) {
#864 ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#866    if (ncattcopy(cdfidtt_idatt.namecdfid, 2) != -1) {
#869 ncclose(cdfid); ncclose(cdfid2); return ++nerrs;
#873 ncclose(cdfid); return ++nerrs;
#876    if (ncattcopy(cdfidtt_idatt.namecdfid2tu_id) != -1) {
#879 ncclose(cdfid); return ++nerrs;
#881    if (ncclose (cdfid) == -1) {
#885    if (ncattcopy(cdfidtt_idatt.namecdfid2tu_id) != -1) {
#916    int cdfid; /* netcdf id */
#926    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#931    if (ncredef(cdfid) == -1) {
#933 ncclose(cdfid); return ++nerrs;
#939 if (ncattname(cdfidNC_GLOBALiaatt.name) == -1) {
#941     ncclose(cdfid); return ++nerrs;
#949     ncclose(cdfid); return ++nerrs;
#962     if (ncattname(cdfidiviaatt.name) == -1) {
#964 ncclose(cdfid); return ++nerrs;
#972 ncclose(cdfid); return ++nerrs;
#984    if (ncattput(cdfidNC_GLOBALatt.nameatt.typeatt.lenatt.val)
#987 ncclose(cdfid); return ++nerrs;
#992    if (ncattname(cdfidNC_GLOBALtest.ngatts-1, tmp.name) == -1) {
#994 ncclose(cdfid); return ++nerrs;
#1001    if (ncendef (cdfid) == -1) {
#1003 ncclose(cdfid); return ++nerrs;
#1009 if (ncattname(cdfidNC_GLOBALiaatt.name) == -1) {
#1011     ncclose(cdfid); return ++nerrs;
#1019     ncclose(cdfid); return ++nerrs;
#1032     if (ncattname(cdfidiviaatt.name) == -1) {
#1034 ncclose(cdfid); return ++nerrs;
#1042 ncclose(cdfid); return ++nerrs;
#1053    if (ncattname(cdfidtest.nvars, 0, att.name) != -1) {
#1055 ncclose(cdfid); return ++nerrs;
#1058    if (ncattname(cdfidNC_GLOBAL, -1, att.name) != -1) {
#1060 ncclose(cdfid); return ++nerrs;
#1062    if (ncattname(cdfidNC_GLOBALtest.ngattsatt.name) != -1) {
#1064 ncclose(cdfid); return ++nerrs;
#1066    if (ncclose (cdfid) == -1) {
#1072    if (ncattname(cdfidNC_GLOBAL, 0, att.name) != -1) {
#1102    int cdfid; /* netcdf id */
#1115    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#1120    if (ncredef(cdfid) == -1) {
#1122 ncclose(cdfid); return ++nerrs;
#1125    if (ncattput(cdfidNC_GLOBALatty.nameatty.typeatty.len,
#1128 ncclose(cdfid); return ++nerrs;
#1132    if (ncattput(cdfidNC_GLOBALattz.nameattz.typeattz.len,
#1135 ncclose(cdfid); return ++nerrs;
#1140    if (ncattrename(cdfidNC_GLOBALatty.namenewname) == -1) {
#1142 ncclose(cdfid); return ++nerrs;
#1146    if (ncattinq(cdfidNC_GLOBALnewname, &tmp.type, &tmp.len) == -1) {
#1148 ncclose(cdfid); return ++nerrs;
#1152 ncclose(cdfid); return ++nerrs;
#1156    if (ncattget(cdfidNC_GLOBALnewnametmp.val) == -1) {
#1158 ncclose(cdfid); return ++nerrs;
#1165    if (ncattinq(cdfidNC_GLOBALatty.name, &tmp.type, &tmp.len) != -1) {
#1167 ncclose(cdfid); return ++nerrs;
#1170    if (ncattrename(cdfidNC_GLOBALattz.namenewname) != -1) {
#1172 ncclose(cdfid); return ++nerrs;
#1175    if (ncattrename(cdfidNC_GLOBALattz.namelongername) == -1) {
#1177 ncclose(cdfid); return ++nerrs;
#1180    if (ncattrename(cdfidtest.nvarsnewnameatty.name) != -1) {
#1182 ncclose(cdfid); return ++nerrs;
#1185    if (ncattrename(cdfidNC_GLOBAL, "nonesuch", newname) != -1) {
#1188 ncclose(cdfid); return ++nerrs;
#1190    if (ncendef (cdfid) == -1) {
#1192 ncclose(cdfid); return ++nerrs;
#1195    if (ncattrename(cdfidNC_GLOBALnewname, "short") == -1) {
#1197 ncclose(cdfid); return ++nerrs;
#1199    if (ncattrename(cdfidNC_GLOBAL, "short", "plugh") == -1) {
#1201 ncclose(cdfid); return ++nerrs;
#1203    if (ncattget(cdfidNC_GLOBAL, "plugh", tmp.val) == -1) {
#1205 ncclose(cdfid); return ++nerrs;
#1213    if (ncclose (cdfid) == -1) {
#1218    if (ncattrename(cdfidNC_GLOBALnewnameatty.name) != -1) {
#1220 ncclose(cdfid); return ++nerrs;
#1245    int cdfid; /* netcdf id */
#1264    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#1269    if (ncredef(cdfid) == -1) {
#1271 ncclose(cdfid); return ++nerrs;
#1274    if (ncattput(cdfidNC_GLOBALyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1276 ncclose(cdfid); return ++nerrs;
#1282    if ((yav_id=ncvardef(cdfidyav.nameyav.typeyav.ndimsyav.dims))
#1285 ncclose(cdfid); return ++nerrs;
#1288    if (ncattput(cdfidyav_idyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1290 ncclose(cdfid); return ++nerrs;
#1295    if (ncinquire(cdfid, &ndims, &nvars, &ngatts1, &xdimid) == -1) {
#1297 ncclose(cdfid); return ++nerrs;
#1301    if (ncvarinq(cdfidyav_idvtmp.name, &vtmp.type, &vtmp.ndimsvtmp.dims,
#1304 ncclose(cdfid); return ++nerrs;
#1308    if (ncattdel(cdfidNC_GLOBALyaa.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(cdfidNC_GLOBALyaa.name, &atmp.type, &atmp.len) != -1) {
#1324 ncclose(cdfid); return ++nerrs;
#1328    if (ncattdel(cdfidyav_idyaa.name) == -1) {
#1330 ncclose(cdfid); return ++nerrs;
#1333    if (ncvarinq(cdfidyav_idvtmp.name, &vtmp.type, &vtmp.ndims,
#1336 ncclose(cdfid); return ++nerrs;
#1341 ncclose(cdfid); return ++nerrs;
#1343    if (ncattinq(cdfidyav_idyaa.name, &atmp.type, &atmp.len) != -1) {
#1346 ncclose(cdfid); return ++nerrs;
#1349    if (ncattput(cdfidNC_GLOBALyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1351 ncclose(cdfid); return ++nerrs;
#1354    if (ncattput(cdfidyav_idyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1356 ncclose(cdfid); return ++nerrs;
#1360    if (ncattdel(cdfidyav_id, "nonesuch") != -1) {
#1362 ncclose(cdfid); return ++nerrs;
#1365    if (ncattdel(cdfidtest.nvarsyaa.name) != -1) {
#1367 ncclose(cdfid); return ++nerrs;
#1369    if (ncendef (cdfid) == -1) {
#1371 ncclose(cdfid); return ++nerrs;
#1374    if (ncattdel(cdfidNC_GLOBALyaa.name) != -1) {
#1376 ncclose(cdfid); return ++nerrs;
#1378    if (ncclose (cdfid) == -1) {
#1383    if (ncattdel(cdfidyav_idyaa.name) != -1) {
dimtests.c#33    int cdfid; /* netcdf id */
#48    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#53    if (ncdimdef(cdfidmm.namemm.size) != -1) {
#55 ncclose(cdfid); return ++nerrs;
#58    if (ncredef(cdfid) == -1) {
#60 ncclose(cdfid); return ++nerrs;
#63    if ((dimid = ncdimdef(cdfidmm.namemm.size)) == -1) {
#65 ncclose(cdfid); return ++nerrs;
#72 ncclose(cdfid); return ++nerrs;
#76    if (ncdimdef(cdfidmm.namemm.size) != -1) {
#78 ncclose(cdfid); return ++nerrs;
#81    if (ncdimdef(cdfidnn.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(cdfidrec.namerec.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(pathNC_WRITE)) == -1) {
#149    if (ncredef(cdfid) == -1) {
#151 ncclose(cdfid); return ++nerrs;
#154    if ((nn_dim = ncdimdef(cdfidnn.namenn.size)) == -1) {
#156 ncclose(cdfid); return ++nerrs;
#160    if (ncdimid(cdfidnn.name) != nn_dim) {
#162 ncclose(cdfid); return ++nerrs;
#164    if (ncendef (cdfid) == -1) {
#166 ncclose(cdfid); return ++nerrs;
#169    if (ncdimid(cdfidnn.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(cdfidnn.name) != -1) {
#214    int cdfid; /* netcdf id */
#220    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#227 if (ncdiminq(cdfiddimiddim.name, &dim.size) == -1) {
#230     ncclose(cdfid); return ++nerrs;
#244    if (ncredef(cdfid) == -1) {
#246 ncclose(cdfid); return ++nerrs;
#250 if (ncdiminq(cdfiddimiddim.name, &dim.size) == -1) {
#253     ncclose(cdfid); return ++nerrs;
#268    if (ncdiminq(cdfid, -1, dim.name, &dim.size) != -1 ||
#269 ncdiminq(cdfidtest.ndimsdim.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(pathNC_WRITE)) == -1) {
#328    if (ncredef(cdfid) == -1) {
#330 ncclose(cdfid); return ++nerrs;
#333    if ((pp_dim = ncdimdef(cdfidpp.namepp.size)) == -1) {
#335 ncclose(cdfid); return ++nerrs;
#338    if (ncdimdef(cdfidqq.nameqq.size) == -1) {
#340 ncclose(cdfid); return ++nerrs;
#344    if (ncdimrename(cdfidpp_dimnewname) == -1) {
#346 ncclose(cdfid); return ++nerrs;
#350    if (ncdiminq(cdfidpp_dimdim.name, &dim.size) == -1) {
#352 ncclose(cdfid); return ++nerrs;
#356 ncclose(cdfid); return ++nerrs;
#361 ncclose(cdfid); return ++nerrs;
#367    if (ncdimrename(cdfidpp_dimqq.name) != -1) {
#369 ncclose(cdfid); return ++nerrs;
#372    if (ncdimrename(cdfid, -1, dim.name) != -1 ||
#373 ncdimrename(cdfidtest.ndimsdim.name) != -1) {
#376 ncclose(cdfid); return ++nerrs;
#378    if (ncendef (cdfid) == -1) {
#380 ncclose(cdfid); return ++nerrs;
#384    if (ncdimrename(cdfidpp_dim, "p") == -1) {
#386 ncclose(cdfid); return ++nerrs;
#392    if (pp_dim != ncdimid(cdfid, "p")) {
#398    if (ncdimrename(cdfidpp_dimpp.name) == -1) {
#400 ncclose(cdfid); return ++nerrs;
#405    if (ncclose (cdfid) == -1) {
#410    if (ncdimrename (cdfid, 0, dim.name) != -1) {
slabs.c#112test_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(cdfiddims[idim].namedims[idim].size);
#151     ncclose(cdfid);
#163 varid[iv] = ncvardef(cdfidva[iv].nameva[iv].typeva[iv].ndims,
#167     ncclose(cdfid); return 1;
#173    if (ncendef (cdfid) == -1) {
#175 ncclose(cdfid); return 1;
#206 if (ncvarput(cdfidvarid[iv], corneredge, (void *) v) == -1) {
#223 if (ncvarget(cdfidvarid[iv], corneredge, (void *) v) == -1) {
#242     if (ncvarget(cdfidvarid[iv], corneredge, (void *) v) == -1) {
#268 if (ncvarget(cdfidvarid[iv], corneredge, (void *) v) == -1) {
#307     if (ncvarget(cdfidvarid[iv], corneredge, (void *) v) == -1) {
t_nc.c#108createtestdims(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)
#122testdims(int cdfid, size_t num_dims, size_t *sizes, const char * const dim_names[])
#129 assert( nc_inq_dim(cdfidiicp, &size) == NC_NOERR);
vardef.c#112    int cdfid; /* netcdf id */
#137    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#142    if (ncvardef(cdfidva[0].nameva[0].typeva[0].ndimsva[0].dims)
#145 ncclose(cdfid); return ++nerrs;
#148    if (ncredef(cdfid) == -1) {
#150 ncclose(cdfid); return ++nerrs;
#155 if ((di_id[id] = ncdimdef(cdfiddi[id].namedi[id].size)) == -1) {
#158     ncclose(cdfid); return ++nerrs;
#172 if ((va_id[iv] = ncvardef(cdfidva[iv].nameva[iv].type,
#176     ncclose(cdfid); return ++nerrs;
#183     ncclose(cdfid); return ++nerrs;
#186 if (ncvarinq(cdfidva_id[iv], tmp.name, &tmp.type,
#190     ncclose(cdfid); return ++nerrs;
#213    if (ncvardef(cdfidva[0].nameva[0].type,
#216 ncclose(cdfid); return ++nerrs;
#219    if (ncvardef(cdfid, "badtype", BAD_TYPEva[0].ndimsva[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].typeva[0].ndimsva[0].dims)
#234 ncclose(cdfid); return ++nerrs;
#236    if (ncendef (cdfid) == -1) {
#238 ncclose(cdfid); return ++nerrs;
#249 if (ncvarget1(cdfidva_id[iv], where, (void *) &val) != -1) {
#263 if (ncvarget1(cdfidva_id[iv], where, (void *) &val) != -1) {
#277 if (ncvarget1(cdfidva_id[iv], where, (void *) &val) != -1) {
#291 if (ncvarget1(cdfidva_id[iv], where, (void *) &val) != -1) {
#306 if (ncvarget1(cdfidva_id[iv], where, (void *) &val) != -1) {
#320 if (ncvarget1(cdfidva_id[iv], where, (void *) &val) != -1) {
#337    if (ncclose (cdfid) == -1) {
varget.c#32    int cdfid; /* netcdf id */
#42    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#47    nerrs += test_varputget (cdfid);
#50    nerrs += test_slabs (cdfid);
#70 if(ncvarget (cdfidivhc.corhc.edghc.vals) != -1) {
#72     ncclose(cdfid); return ++nerrs;
#77 if(ncvarget (cdfidivhc.corhc.edghc.vals) != -1) {
#79     ncclose(cdfid); return ++nerrs;
#89 if(ncvarget (cdfidivhc.corhc.edghc.vals) != -1) {
#91     ncclose(cdfid); return ++nerrs;
#96 if(ncvarget (cdfidivhc.corhc.edghc.vals) != -1) {
#98     ncclose(cdfid); return ++nerrs;
#103 if (ncredef(cdfid) == -1) {
#105     ncclose(cdfid); return ++nerrs;
#108 if(ncvarget (cdfidivhc.corhc.edghc.vals) != -1) {
#111     ncclose(cdfid); return ++nerrs;
#113 if (ncendef (cdfid) == -1) {
#115     ncclose(cdfid); return ++nerrs;
#119    if(ncvarget (cdfid, -1, hc.corhc.edghc.vals) != -1) {
#121 ncclose(cdfid); return ++nerrs;
#123    if (ncclose (cdfid) == -1) {
#128    if(ncvarget (cdfid, 0, hc.corhc.edghc.vals) != -1) {
vargetg.c#33    int cdfid; /* netcdf id */
#44    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#49    nerrs += test_varputgetg (cdfid);
#70     (ncvarputg(cdfidvaridhc.corhc.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(pathNC_WRITE)) == -1) {
#56    nerrs += test_varputget (cdfid); /* prints messages for discrepencies */
#75 if(ncvarput (cdfidivhc.corhc.edghc.vals) != -1) {
#77     ncclose(cdfid); return ++nerrs;
#82 if(ncvarput (cdfidivhc.corhc.edghc.vals) != -1) {
#84     ncclose(cdfid); return ++nerrs;
#93 if(ncvarput (cdfidivhc.corhc.edghc.vals) != -1) {
#95     ncclose(cdfid); return ++nerrs;
#101 if(ncvarput (cdfidivhc.corhc.edghc.vals) != -1) {
#103     ncclose(cdfid); return ++nerrs;
#108 if (ncredef(cdfid) == -1) {
#110     ncclose(cdfid); return ++nerrs;
#113 if(ncvarput (cdfidivhc.corhc.edghc.vals) != -1) {
#115     ncclose(cdfid); return ++nerrs;
#117 if (ncendef (cdfid) == -1) {
#119     ncclose(cdfid); return ++nerrs;
#125    if(ncvarput (cdfid, -1, hc.corhc.edghc.vals) != -1) {
#127 ncclose(cdfid); return ++nerrs;
#129    if (ncclose (cdfid) == -1) {
#134    if(ncvarput (cdfid, 0, hc.corhc.edghc.vals) != -1) {
varputg.c#33    int cdfid; /* netcdf id */
#46    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#53    nerrs += test_varputgetg (cdfid);
#73     (ncvarputg(cdfidvaridhc.corhc.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(pathNC_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(cdfidxx.name) != varid) {
#64 ncclose(cdfid); return ++nerrs;
#66    if (ncendef (cdfid) == -1) {
#68 ncclose(cdfid); return ++nerrs;
#71    if (ncvarid(cdfidxx.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(cdfidxx.name) != -1) {
#112    int cdfid; /* netcdf id */
#119    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#127 if (ncvarinq(cdfidvaridvar.name, &var.type,
#131     ncclose(cdfid); return ++nerrs;
#159    if (ncredef(cdfid) == -1) {
#161 ncclose(cdfid); return ++nerrs;
#165 if (ncvarinq(cdfidvaridvar.name, &var.type,
#169     ncclose(cdfid); return ++nerrs;
#197    if (ncvarinq(cdfid, -1, var.name, &var.type,
#199 ncvarinq(cdfidtest.nvarsvar.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(cdfidvaridvar.name, &var.type,
#252test_varputget1(cdfid)
#253     int cdfid; /* handle of netcdf open and in data mode */
#314     if(ncvarput1 (cdfidivelm[ie].coordsvoidp) == -1) {
#317 ncclose(cdfid); return 1;
#321     if(ncvarget1 (cdfidivelm[ie].coordstmpp) == -1) {
#324 ncclose(cdfid); return 1;
#388    int cdfid; /* netcdf id */
#394    if ((cdfid = ncopen(pathNC_WRITE)) == -1) {
#399    nerrs += test_varputget1 (cdfid); /* tests ncvarput1 and ncvarget1 */
#412 if(ncvarput1 (cdfidivelm.coords, (void *) &elm.val) != -1) {
#414     ncclose(cdfid); return ++nerrs;
#418 if(ncvarput1 (cdfidivelm.coords, (void *) &elm.val) != -1) {
#420     ncclose(cdfid); return ++nerrs;
#424    if(ncvarput1 (cdfid, -1, elm.coords, (void *) &elm.val) != -1 ||
#425       ncvarput1 (cdfidtest.nvarselm.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(pathNC_WRITE)) == -1) {
#487    nerrs += test_varputget1 (cdfid); /* tests ncvarput1 and ncvarget1 */
#500 if(ncvarget1 (cdfidivelm.coords, (void *) &elm.val) != -1) {
#502     ncclose(cdfid); return ++nerrs;
#506 if(ncvarget1 (cdfidivelm.coords, (void *) &elm.val) != -1) {
#508     ncclose(cdfid); return ++nerrs;
#512    if(ncvarget1 (cdfid, -1, elm.coords, (void *) &elm.val) != -1 ||
#513       ncvarget1 (cdfidtest.nvarselm.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(pathNC_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(cdfidzz.namezz.typezz.ndimszz.dims) == -1) {
#601 ncclose(cdfid); return ++nerrs;
#606    if (ncvarrename(cdfidyy_idnewname) == -1) {
#608 ncclose(cdfid); return ++nerrs;
#611    if (yy_id != ncvarid(cdfidnewname)) {
#616    if (ncvarinq(cdfidyy_idvar.name,
#619 ncclose(cdfid); return ++nerrs;
#623 ncclose(cdfid); return ++nerrs;
#628 ncclose(cdfid); return ++nerrs;
#632    if (ncvarrename(cdfidyy_idzz.name) != -1) {
#634 ncclose(cdfid); return ++nerrs;
#637    if (ncvarrename(cdfid, -1, var.name) != -1 ||
#638 ncvarrename(cdfidtest.nvarsvar.name) != -1) {
#641 ncclose(cdfid); return ++nerrs;
#643    if (ncendef (cdfid) == -1) {
#645 ncclose(cdfid); return ++nerrs;
#648    if (ncvarrename(cdfidyy_id, "a_longer_name") != -1) {
#650 ncclose(cdfid); return ++nerrs;
#652    if (ncvarrename(cdfidyy_idshortname) == -1) {
#654 ncclose(cdfid); return ++nerrs;
#658    if (yy_id != ncvarid(cdfidshortname)) {
#662    if (ncclose (cdfid) == -1) {
#667    if (ncvarrename (cdfid, 0, var.name) != -1) {
vputget.c#37test_varputget(cdfid)
#38     int cdfid; /* handle of netcdf open and in data mode */
#86 if(ncvarput (cdfidivhc[ie].corhc[ie].edghc[ie].vals)
#105     if(ncvarget (cdfidivhc[ie].corhc[ie].edgtmp.vals)
vputgetg.c#37test_varputgetg(cdfid)
#38     int cdfid; /* handle of netcdf open and in data mode */
#120     if(ncvarputg (cdfidivhc[ie].corhc[ie].npts,
#155 if(ncvargetg (cdfidivhc[ie].corhc[ie].npts,


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