00001
00002
00003
00004
00005
00006
00007
00008
00009 #include "tests.h"
00010
00011
00012
00013
00014
00015 static
00016 double
00017 hash_text(
00018 const nc_type type,
00019 const int rank,
00020 const size_t *index,
00021 const nct_itype itype)
00022 {
00023 const double min = text_min;
00024 const double max = text_max;
00025
00026 return MAX(min, MIN(max, hash4( type, rank, index, itype)));
00027 }
00028
00029
00030
00031
00032 static
00033 double
00034 hash_uchar(
00035 const nc_type type,
00036 const int rank,
00037 const size_t *index,
00038 const nct_itype itype)
00039 {
00040 const double min = uchar_min;
00041 const double max = uchar_max;
00042
00043 return MAX(min, MIN(max, hash4( type, rank, index, itype)));
00044 }
00045
00046
00047
00048
00049 static
00050 double
00051 hash_schar(
00052 const nc_type type,
00053 const int rank,
00054 const size_t *index,
00055 const nct_itype itype)
00056 {
00057 const double min = schar_min;
00058 const double max = schar_max;
00059
00060 return MAX(min, MIN(max, hash4( type, rank, index, itype)));
00061 }
00062
00063
00064
00065
00066 static
00067 double
00068 hash_short(
00069 const nc_type type,
00070 const int rank,
00071 const size_t *index,
00072 const nct_itype itype)
00073 {
00074 const double min = short_min;
00075 const double max = short_max;
00076
00077 return MAX(min, MIN(max, hash4( type, rank, index, itype)));
00078 }
00079
00080
00081
00082
00083 static
00084 double
00085 hash_int(
00086 const nc_type type,
00087 const int rank,
00088 const size_t *index,
00089 const nct_itype itype)
00090 {
00091 const double min = int_min;
00092 const double max = int_max;
00093
00094 return MAX(min, MIN(max, hash4( type, rank, index, itype)));
00095 }
00096
00097
00098
00099
00100 static
00101 double
00102 hash_long(
00103 const nc_type type,
00104 const int rank,
00105 const size_t *index,
00106 const nct_itype itype)
00107 {
00108 const double min = long_min;
00109 const double max = long_max;
00110
00111 return MAX(min, MIN(max, hash4( type, rank, index, itype)));
00112 }
00113
00114
00115
00116
00117 static
00118 double
00119 hash_float(
00120 const nc_type type,
00121 const int rank,
00122 const size_t *index,
00123 const nct_itype itype)
00124 {
00125 const double min = float_min;
00126 const double max = float_max;
00127
00128 return MAX(min, MIN(max, hash4( type, rank, index, itype)));
00129 }
00130
00131
00132
00133
00134 static
00135 double
00136 hash_double(
00137 const nc_type type,
00138 const int rank,
00139 const size_t *index,
00140 const nct_itype itype)
00141 {
00142 const double min = double_min;
00143 const double max = double_max;
00144
00145 return MAX(min, MIN(max, hash4( type, rank, index, itype)));
00146 }
00147
00148
00149
00150
00151
00152
00153
00154 static
00155 void
00156 check_vars_text(const char *filename)
00157 {
00158 int ncid;
00159 size_t index[MAX_RANK];
00160 int err;
00161 int d;
00162 int i;
00163 size_t j;
00164 text value;
00165 nc_type datatype;
00166 int ndims;
00167 int dimids[MAX_RANK];
00168 double expect;
00169 char name[NC_MAX_NAME];
00170 size_t length;
00171 int canConvert;
00172 int nok = 0;
00173
00174 err = nc_open(filename, NC_NOWRITE, &ncid);
00175 IF (err)
00176 error("nc_open: %s", nc_strerror(err));
00177
00178 for (i = 0; i < NVARS; i++) {
00179 canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
00180 if (canConvert) {
00181 err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);
00182 IF (err)
00183 error("nc_inq_var: %s", nc_strerror(err));
00184 IF (strcmp(name, var_name[i]) != 0)
00185 error("Unexpected var_name");
00186 IF (datatype != var_type[i])
00187 error("Unexpected type");
00188 IF (ndims != var_rank[i])
00189 error("Unexpected rank");
00190 for (j = 0; j < ndims; j++) {
00191 err = nc_inq_dim(ncid, dimids[j], 0, &length);
00192 IF (err)
00193 error("nc_inq_dim: %s", nc_strerror(err));
00194 IF (length != var_shape[i][j])
00195 error("Unexpected shape");
00196 }
00197 for (j = 0; j < var_nels[i]; j++) {
00198 err = toMixedBase(j, var_rank[i], var_shape[i], index);
00199 IF (err)
00200 error("error in toMixedBase 2");
00201 expect = hash4( var_type[i], var_rank[i], index, NCT_TEXT);
00202 err = nc_get_var1_text(ncid, i, index, &value);
00203 if (inRange3(expect,datatype,NCT_TEXT)) {
00204 if (expect >= text_min && expect <= text_max) {
00205 IF (err) {
00206 error("nc_get_var1_text: %s", nc_strerror(err));
00207 } else {
00208 IF (!equal(value,expect,var_type[i],NCT_TEXT)) {
00209 error("Var value read not that expected");
00210 if (verbose) {
00211 error("\n");
00212 error("varid: %d, ", i);
00213 error("var_name: %s, ", var_name[i]);
00214 error("index:");
00215 for (d = 0; d < var_rank[i]; d++)
00216 error(" %d", index[d]);
00217 error(", expect: %g, ", expect);
00218 error("got: %g", (double) value);
00219 }
00220 } else {
00221 ++nok;
00222 }
00223 }
00224 }
00225 }
00226 }
00227 }
00228 }
00229 err = nc_close (ncid);
00230 IF (err)
00231 error("nc_close: %s", nc_strerror(err));
00232 print_nok(nok);
00233 }
00234
00235
00236
00237
00238 static
00239 void
00240 check_vars_uchar(const char *filename)
00241 {
00242 int ncid;
00243 size_t index[MAX_RANK];
00244 int err;
00245 int d;
00246 int i;
00247 size_t j;
00248 uchar value;
00249 nc_type datatype;
00250 int ndims;
00251 int dimids[MAX_RANK];
00252 double expect;
00253 char name[NC_MAX_NAME];
00254 size_t length;
00255 int canConvert;
00256 int nok = 0;
00257
00258 err = nc_open(filename, NC_NOWRITE, &ncid);
00259 IF (err)
00260 error("nc_open: %s", nc_strerror(err));
00261
00262 for (i = 0; i < NVARS; i++) {
00263 canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
00264 if (canConvert) {
00265 err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);
00266 IF (err)
00267 error("nc_inq_var: %s", nc_strerror(err));
00268 IF (strcmp(name, var_name[i]) != 0)
00269 error("Unexpected var_name");
00270 IF (datatype != var_type[i])
00271 error("Unexpected type");
00272 IF (ndims != var_rank[i])
00273 error("Unexpected rank");
00274 for (j = 0; j < ndims; j++) {
00275 err = nc_inq_dim(ncid, dimids[j], 0, &length);
00276 IF (err)
00277 error("nc_inq_dim: %s", nc_strerror(err));
00278 IF (length != var_shape[i][j])
00279 error("Unexpected shape");
00280 }
00281 for (j = 0; j < var_nels[i]; j++) {
00282 err = toMixedBase(j, var_rank[i], var_shape[i], index);
00283 IF (err)
00284 error("error in toMixedBase 2");
00285 expect = hash4( var_type[i], var_rank[i], index, NCT_UCHAR);
00286 err = nc_get_var1_uchar(ncid, i, index, &value);
00287 if (inRange3(expect,datatype,NCT_UCHAR)) {
00288 if (expect >= uchar_min && expect <= uchar_max) {
00289 IF (err) {
00290 error("nc_get_var1_uchar: %s", nc_strerror(err));
00291 } else {
00292 IF (!equal(value,expect,var_type[i],NCT_UCHAR)) {
00293 error("Var value read not that expected");
00294 if (verbose) {
00295 error("\n");
00296 error("varid: %d, ", i);
00297 error("var_name: %s, ", var_name[i]);
00298 error("index:");
00299 for (d = 0; d < var_rank[i]; d++)
00300 error(" %d", index[d]);
00301 error(", expect: %g, ", expect);
00302 error("got: %g", (double) value);
00303 }
00304 } else {
00305 ++nok;
00306 }
00307 }
00308 }
00309 }
00310 }
00311 }
00312 }
00313 err = nc_close (ncid);
00314 IF (err)
00315 error("nc_close: %s", nc_strerror(err));
00316 print_nok(nok);
00317 }
00318
00319
00320
00321
00322 static
00323 void
00324 check_vars_schar(const char *filename)
00325 {
00326 int ncid;
00327 size_t index[MAX_RANK];
00328 int err;
00329 int d;
00330 int i;
00331 size_t j;
00332 schar value;
00333 nc_type datatype;
00334 int ndims;
00335 int dimids[MAX_RANK];
00336 double expect;
00337 char name[NC_MAX_NAME];
00338 size_t length;
00339 int canConvert;
00340 int nok = 0;
00341
00342 err = nc_open(filename, NC_NOWRITE, &ncid);
00343 IF (err)
00344 error("nc_open: %s", nc_strerror(err));
00345
00346 for (i = 0; i < NVARS; i++) {
00347 canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
00348 if (canConvert) {
00349 err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);
00350 IF (err)
00351 error("nc_inq_var: %s", nc_strerror(err));
00352 IF (strcmp(name, var_name[i]) != 0)
00353 error("Unexpected var_name");
00354 IF (datatype != var_type[i])
00355 error("Unexpected type");
00356 IF (ndims != var_rank[i])
00357 error("Unexpected rank");
00358 for (j = 0; j < ndims; j++) {
00359 err = nc_inq_dim(ncid, dimids[j], 0, &length);
00360 IF (err)
00361 error("nc_inq_dim: %s", nc_strerror(err));
00362 IF (length != var_shape[i][j])
00363 error("Unexpected shape");
00364 }
00365 for (j = 0; j < var_nels[i]; j++) {
00366 err = toMixedBase(j, var_rank[i], var_shape[i], index);
00367 IF (err)
00368 error("error in toMixedBase 2");
00369 expect = hash4( var_type[i], var_rank[i], index, NCT_SCHAR);
00370 err = nc_get_var1_schar(ncid, i, index, &value);
00371 if (inRange3(expect,datatype,NCT_SCHAR)) {
00372 if (expect >= schar_min && expect <= schar_max) {
00373 IF (err) {
00374 error("nc_get_var1_schar: %s", nc_strerror(err));
00375 } else {
00376 IF (!equal(value,expect,var_type[i],NCT_SCHAR)) {
00377 error("Var value read not that expected");
00378 if (verbose) {
00379 error("\n");
00380 error("varid: %d, ", i);
00381 error("var_name: %s, ", var_name[i]);
00382 error("index:");
00383 for (d = 0; d < var_rank[i]; d++)
00384 error(" %d", index[d]);
00385 error(", expect: %g, ", expect);
00386 error("got: %g", (double) value);
00387 }
00388 } else {
00389 ++nok;
00390 }
00391 }
00392 }
00393 }
00394 }
00395 }
00396 }
00397 err = nc_close (ncid);
00398 IF (err)
00399 error("nc_close: %s", nc_strerror(err));
00400 print_nok(nok);
00401 }
00402
00403
00404
00405
00406 static
00407 void
00408 check_vars_short(const char *filename)
00409 {
00410 int ncid;
00411 size_t index[MAX_RANK];
00412 int err;
00413 int d;
00414 int i;
00415 size_t j;
00416 short value;
00417 nc_type datatype;
00418 int ndims;
00419 int dimids[MAX_RANK];
00420 double expect;
00421 char name[NC_MAX_NAME];
00422 size_t length;
00423 int canConvert;
00424 int nok = 0;
00425
00426 err = nc_open(filename, NC_NOWRITE, &ncid);
00427 IF (err)
00428 error("nc_open: %s", nc_strerror(err));
00429
00430 for (i = 0; i < NVARS; i++) {
00431 canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
00432 if (canConvert) {
00433 err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);
00434 IF (err)
00435 error("nc_inq_var: %s", nc_strerror(err));
00436 IF (strcmp(name, var_name[i]) != 0)
00437 error("Unexpected var_name");
00438 IF (datatype != var_type[i])
00439 error("Unexpected type");
00440 IF (ndims != var_rank[i])
00441 error("Unexpected rank");
00442 for (j = 0; j < ndims; j++) {
00443 err = nc_inq_dim(ncid, dimids[j], 0, &length);
00444 IF (err)
00445 error("nc_inq_dim: %s", nc_strerror(err));
00446 IF (length != var_shape[i][j])
00447 error("Unexpected shape");
00448 }
00449 for (j = 0; j < var_nels[i]; j++) {
00450 err = toMixedBase(j, var_rank[i], var_shape[i], index);
00451 IF (err)
00452 error("error in toMixedBase 2");
00453 expect = hash4( var_type[i], var_rank[i], index, NCT_SHORT);
00454 err = nc_get_var1_short(ncid, i, index, &value);
00455 if (inRange3(expect,datatype,NCT_SHORT)) {
00456 if (expect >= short_min && expect <= short_max) {
00457 IF (err) {
00458 error("nc_get_var1_short: %s", nc_strerror(err));
00459 } else {
00460 IF (!equal(value,expect,var_type[i],NCT_SHORT)) {
00461 error("Var value read not that expected");
00462 if (verbose) {
00463 error("\n");
00464 error("varid: %d, ", i);
00465 error("var_name: %s, ", var_name[i]);
00466 error("index:");
00467 for (d = 0; d < var_rank[i]; d++)
00468 error(" %d", index[d]);
00469 error(", expect: %g, ", expect);
00470 error("got: %g", (double) value);
00471 }
00472 } else {
00473 ++nok;
00474 }
00475 }
00476 }
00477 }
00478 }
00479 }
00480 }
00481 err = nc_close (ncid);
00482 IF (err)
00483 error("nc_close: %s", nc_strerror(err));
00484 print_nok(nok);
00485 }
00486
00487
00488
00489
00490 static
00491 void
00492 check_vars_int(const char *filename)
00493 {
00494 int ncid;
00495 size_t index[MAX_RANK];
00496 int err;
00497 int d;
00498 int i;
00499 size_t j;
00500 int value;
00501 nc_type datatype;
00502 int ndims;
00503 int dimids[MAX_RANK];
00504 double expect;
00505 char name[NC_MAX_NAME];
00506 size_t length;
00507 int canConvert;
00508 int nok = 0;
00509
00510 err = nc_open(filename, NC_NOWRITE, &ncid);
00511 IF (err)
00512 error("nc_open: %s", nc_strerror(err));
00513
00514 for (i = 0; i < NVARS; i++) {
00515 canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
00516 if (canConvert) {
00517 err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);
00518 IF (err)
00519 error("nc_inq_var: %s", nc_strerror(err));
00520 IF (strcmp(name, var_name[i]) != 0)
00521 error("Unexpected var_name");
00522 IF (datatype != var_type[i])
00523 error("Unexpected type");
00524 IF (ndims != var_rank[i])
00525 error("Unexpected rank");
00526 for (j = 0; j < ndims; j++) {
00527 err = nc_inq_dim(ncid, dimids[j], 0, &length);
00528 IF (err)
00529 error("nc_inq_dim: %s", nc_strerror(err));
00530 IF (length != var_shape[i][j])
00531 error("Unexpected shape");
00532 }
00533 for (j = 0; j < var_nels[i]; j++) {
00534 err = toMixedBase(j, var_rank[i], var_shape[i], index);
00535 IF (err)
00536 error("error in toMixedBase 2");
00537 expect = hash4( var_type[i], var_rank[i], index, NCT_INT);
00538 err = nc_get_var1_int(ncid, i, index, &value);
00539 if (inRange3(expect,datatype,NCT_INT)) {
00540 if (expect >= int_min && expect <= int_max) {
00541 IF (err) {
00542 error("nc_get_var1_int: %s", nc_strerror(err));
00543 } else {
00544 IF (!equal(value,expect,var_type[i],NCT_INT)) {
00545 error("Var value read not that expected");
00546 if (verbose) {
00547 error("\n");
00548 error("varid: %d, ", i);
00549 error("var_name: %s, ", var_name[i]);
00550 error("index:");
00551 for (d = 0; d < var_rank[i]; d++)
00552 error(" %d", index[d]);
00553 error(", expect: %g, ", expect);
00554 error("got: %g", (double) value);
00555 }
00556 } else {
00557 ++nok;
00558 }
00559 }
00560 }
00561 }
00562 }
00563 }
00564 }
00565 err = nc_close (ncid);
00566 IF (err)
00567 error("nc_close: %s", nc_strerror(err));
00568 print_nok(nok);
00569 }
00570
00571
00572
00573
00574 static
00575 void
00576 check_vars_long(const char *filename)
00577 {
00578 int ncid;
00579 size_t index[MAX_RANK];
00580 int err;
00581 int d;
00582 int i;
00583 size_t j;
00584 long value;
00585 nc_type datatype;
00586 int ndims;
00587 int dimids[MAX_RANK];
00588 double expect;
00589 char name[NC_MAX_NAME];
00590 size_t length;
00591 int canConvert;
00592 int nok = 0;
00593
00594 err = nc_open(filename, NC_NOWRITE, &ncid);
00595 IF (err)
00596 error("nc_open: %s", nc_strerror(err));
00597
00598 for (i = 0; i < NVARS; i++) {
00599 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
00600 if (canConvert) {
00601 err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);
00602 IF (err)
00603 error("nc_inq_var: %s", nc_strerror(err));
00604 IF (strcmp(name, var_name[i]) != 0)
00605 error("Unexpected var_name");
00606 IF (datatype != var_type[i])
00607 error("Unexpected type");
00608 IF (ndims != var_rank[i])
00609 error("Unexpected rank");
00610 for (j = 0; j < ndims; j++) {
00611 err = nc_inq_dim(ncid, dimids[j], 0, &length);
00612 IF (err)
00613 error("nc_inq_dim: %s", nc_strerror(err));
00614 IF (length != var_shape[i][j])
00615 error("Unexpected shape");
00616 }
00617 for (j = 0; j < var_nels[i]; j++) {
00618 err = toMixedBase(j, var_rank[i], var_shape[i], index);
00619 IF (err)
00620 error("error in toMixedBase 2");
00621 expect = hash4( var_type[i], var_rank[i], index, NCT_LONG);
00622 err = nc_get_var1_long(ncid, i, index, &value);
00623 if (inRange3(expect,datatype,NCT_LONG)) {
00624 if (expect >= long_min && expect <= long_max) {
00625 IF (err) {
00626 error("nc_get_var1_long: %s", nc_strerror(err));
00627 } else {
00628 IF (!equal(value,expect,var_type[i],NCT_LONG)) {
00629 error("Var value read not that expected");
00630 if (verbose) {
00631 error("\n");
00632 error("varid: %d, ", i);
00633 error("var_name: %s, ", var_name[i]);
00634 error("index:");
00635 for (d = 0; d < var_rank[i]; d++)
00636 error(" %d", index[d]);
00637 error(", expect: %g, ", expect);
00638 error("got: %g", (double) value);
00639 }
00640 } else {
00641 ++nok;
00642 }
00643 }
00644 }
00645 }
00646 }
00647 }
00648 }
00649 err = nc_close (ncid);
00650 IF (err)
00651 error("nc_close: %s", nc_strerror(err));
00652 print_nok(nok);
00653 }
00654
00655
00656
00657
00658 static
00659 void
00660 check_vars_float(const char *filename)
00661 {
00662 int ncid;
00663 size_t index[MAX_RANK];
00664 int err;
00665 int d;
00666 int i;
00667 size_t j;
00668 float value;
00669 nc_type datatype;
00670 int ndims;
00671 int dimids[MAX_RANK];
00672 double expect;
00673 char name[NC_MAX_NAME];
00674 size_t length;
00675 int canConvert;
00676 int nok = 0;
00677
00678 err = nc_open(filename, NC_NOWRITE, &ncid);
00679 IF (err)
00680 error("nc_open: %s", nc_strerror(err));
00681
00682 for (i = 0; i < NVARS; i++) {
00683 canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
00684 if (canConvert) {
00685 err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);
00686 IF (err)
00687 error("nc_inq_var: %s", nc_strerror(err));
00688 IF (strcmp(name, var_name[i]) != 0)
00689 error("Unexpected var_name");
00690 IF (datatype != var_type[i])
00691 error("Unexpected type");
00692 IF (ndims != var_rank[i])
00693 error("Unexpected rank");
00694 for (j = 0; j < ndims; j++) {
00695 err = nc_inq_dim(ncid, dimids[j], 0, &length);
00696 IF (err)
00697 error("nc_inq_dim: %s", nc_strerror(err));
00698 IF (length != var_shape[i][j])
00699 error("Unexpected shape");
00700 }
00701 for (j = 0; j < var_nels[i]; j++) {
00702 err = toMixedBase(j, var_rank[i], var_shape[i], index);
00703 IF (err)
00704 error("error in toMixedBase 2");
00705 expect = hash4( var_type[i], var_rank[i], index, NCT_FLOAT);
00706 err = nc_get_var1_float(ncid, i, index, &value);
00707 if (inRange3(expect,datatype,NCT_FLOAT)) {
00708 if (expect >= float_min && expect <= float_max) {
00709 IF (err) {
00710 error("nc_get_var1_float: %s", nc_strerror(err));
00711 } else {
00712 IF (!equal(value,expect,var_type[i],NCT_FLOAT)) {
00713 error("Var value read not that expected");
00714 if (verbose) {
00715 error("\n");
00716 error("varid: %d, ", i);
00717 error("var_name: %s, ", var_name[i]);
00718 error("index:");
00719 for (d = 0; d < var_rank[i]; d++)
00720 error(" %d", index[d]);
00721 error(", expect: %g, ", expect);
00722 error("got: %g", (double) value);
00723 }
00724 } else {
00725 ++nok;
00726 }
00727 }
00728 }
00729 }
00730 }
00731 }
00732 }
00733 err = nc_close (ncid);
00734 IF (err)
00735 error("nc_close: %s", nc_strerror(err));
00736 print_nok(nok);
00737 }
00738
00739
00740
00741
00742 static
00743 void
00744 check_vars_double(const char *filename)
00745 {
00746 int ncid;
00747 size_t index[MAX_RANK];
00748 int err;
00749 int d;
00750 int i;
00751 size_t j;
00752 double value;
00753 nc_type datatype;
00754 int ndims;
00755 int dimids[MAX_RANK];
00756 double expect;
00757 char name[NC_MAX_NAME];
00758 size_t length;
00759 int canConvert;
00760 int nok = 0;
00761
00762 err = nc_open(filename, NC_NOWRITE, &ncid);
00763 IF (err)
00764 error("nc_open: %s", nc_strerror(err));
00765
00766 for (i = 0; i < NVARS; i++) {
00767 canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
00768 if (canConvert) {
00769 err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);
00770 IF (err)
00771 error("nc_inq_var: %s", nc_strerror(err));
00772 IF (strcmp(name, var_name[i]) != 0)
00773 error("Unexpected var_name");
00774 IF (datatype != var_type[i])
00775 error("Unexpected type");
00776 IF (ndims != var_rank[i])
00777 error("Unexpected rank");
00778 for (j = 0; j < ndims; j++) {
00779 err = nc_inq_dim(ncid, dimids[j], 0, &length);
00780 IF (err)
00781 error("nc_inq_dim: %s", nc_strerror(err));
00782 IF (length != var_shape[i][j])
00783 error("Unexpected shape");
00784 }
00785 for (j = 0; j < var_nels[i]; j++) {
00786 err = toMixedBase(j, var_rank[i], var_shape[i], index);
00787 IF (err)
00788 error("error in toMixedBase 2");
00789 expect = hash4( var_type[i], var_rank[i], index, NCT_DOUBLE);
00790 err = nc_get_var1_double(ncid, i, index, &value);
00791 if (inRange3(expect,datatype,NCT_DOUBLE)) {
00792 if (expect >= double_min && expect <= double_max) {
00793 IF (err) {
00794 error("nc_get_var1_double: %s", nc_strerror(err));
00795 } else {
00796 IF (!equal(value,expect,var_type[i],NCT_DOUBLE)) {
00797 error("Var value read not that expected");
00798 if (verbose) {
00799 error("\n");
00800 error("varid: %d, ", i);
00801 error("var_name: %s, ", var_name[i]);
00802 error("index:");
00803 for (d = 0; d < var_rank[i]; d++)
00804 error(" %d", index[d]);
00805 error(", expect: %g, ", expect);
00806 error("got: %g", (double) value);
00807 }
00808 } else {
00809 ++nok;
00810 }
00811 }
00812 }
00813 }
00814 }
00815 }
00816 }
00817 err = nc_close (ncid);
00818 IF (err)
00819 error("nc_close: %s", nc_strerror(err));
00820 print_nok(nok);
00821 }
00822
00823
00824
00825
00826
00827
00828
00829
00830 static
00831 void
00832 check_atts_text(int ncid)
00833 {
00834 int err;
00835 int i;
00836 int j;
00837 size_t k;
00838 text value[MAX_NELS];
00839 nc_type datatype;
00840 double expect[MAX_NELS];
00841 size_t length;
00842 size_t nInExtRange;
00843 size_t nInIntRange;
00844 int canConvert;
00845 int nok = 0;
00846
00847 for (i = -1; i < NVARS; i++) {
00848 for (j = 0; j < NATTS(i); j++) {
00849 canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
00850 if (canConvert) {
00851 err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);
00852 IF (err)
00853 error("nc_inq_att: %s", nc_strerror(err));
00854 IF (datatype != ATT_TYPE(i,j))
00855 error("nc_inq_att: unexpected type");
00856 IF (length != ATT_LEN(i,j))
00857 error("nc_inq_att: unexpected length");
00858 assert(length <= MAX_NELS);
00859 nInIntRange = nInExtRange = 0;
00860 for (k = 0; k < length; k++) {
00861 expect[k] = hash4( datatype, -1, &k, NCT_TEXT);
00862 if (inRange3(expect[k], datatype, NCT_TEXT)) {
00863 ++nInExtRange;
00864 if (expect[k] >= text_min && expect[k] <= text_max)
00865 ++nInIntRange;
00866 }
00867 }
00868 err = nc_get_att_text(ncid, i, ATT_NAME(i,j), value);
00869 if (nInExtRange == length && nInIntRange == length) {
00870 IF (err)
00871 error("%s", nc_strerror(err));
00872 } else {
00873 IF (err != 0 && err != NC_ERANGE)
00874 error("OK or Range error: status = %d", err);
00875 }
00876 for (k = 0; k < length; k++) {
00877 if (inRange3(expect[k],datatype,NCT_TEXT)
00878 && expect[k] >= text_min && expect[k] <= text_max) {
00879 IF (!equal(value[k],expect[k],datatype,NCT_TEXT)) {
00880 error("att. value read not that expected");
00881 if (verbose) {
00882 error("\n");
00883 error("varid: %d, ", i);
00884 error("att_name: %s, ", ATT_NAME(i,j));
00885 error("element number: %d ", k);
00886 error("expect: %g, ", expect[k]);
00887 error("got: %g", (double) value[k]);
00888 }
00889 } else {
00890 nok++;
00891 }
00892 }
00893 }
00894 }
00895 }
00896 }
00897
00898 print_nok(nok);
00899 }
00900
00901
00902
00903
00904
00905 static
00906 void
00907 check_atts_uchar(int ncid)
00908 {
00909 int err;
00910 int i;
00911 int j;
00912 size_t k;
00913 uchar value[MAX_NELS];
00914 nc_type datatype;
00915 double expect[MAX_NELS];
00916 size_t length;
00917 size_t nInExtRange;
00918 size_t nInIntRange;
00919 int canConvert;
00920 int nok = 0;
00921
00922 for (i = -1; i < NVARS; i++) {
00923 for (j = 0; j < NATTS(i); j++) {
00924 canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
00925 if (canConvert) {
00926 err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);
00927 IF (err)
00928 error("nc_inq_att: %s", nc_strerror(err));
00929 IF (datatype != ATT_TYPE(i,j))
00930 error("nc_inq_att: unexpected type");
00931 IF (length != ATT_LEN(i,j))
00932 error("nc_inq_att: unexpected length");
00933 assert(length <= MAX_NELS);
00934 nInIntRange = nInExtRange = 0;
00935 for (k = 0; k < length; k++) {
00936 expect[k] = hash4( datatype, -1, &k, NCT_UCHAR);
00937 if (inRange3(expect[k], datatype, NCT_UCHAR)) {
00938 ++nInExtRange;
00939 if (expect[k] >= uchar_min && expect[k] <= uchar_max)
00940 ++nInIntRange;
00941 }
00942 }
00943 err = nc_get_att_uchar(ncid, i, ATT_NAME(i,j), value);
00944 if (nInExtRange == length && nInIntRange == length) {
00945 IF (err)
00946 error("%s", nc_strerror(err));
00947 } else {
00948 IF (err != 0 && err != NC_ERANGE)
00949 error("OK or Range error: status = %d", err);
00950 }
00951 for (k = 0; k < length; k++) {
00952 if (inRange3(expect[k],datatype,NCT_UCHAR)
00953 && expect[k] >= uchar_min && expect[k] <= uchar_max) {
00954 IF (!equal(value[k],expect[k],datatype,NCT_UCHAR)) {
00955 error("att. value read not that expected");
00956 if (verbose) {
00957 error("\n");
00958 error("varid: %d, ", i);
00959 error("att_name: %s, ", ATT_NAME(i,j));
00960 error("element number: %d ", k);
00961 error("expect: %g, ", expect[k]);
00962 error("got: %g", (double) value[k]);
00963 }
00964 } else {
00965 nok++;
00966 }
00967 }
00968 }
00969 }
00970 }
00971 }
00972
00973 print_nok(nok);
00974 }
00975
00976
00977
00978
00979
00980 static
00981 void
00982 check_atts_schar(int ncid)
00983 {
00984 int err;
00985 int i;
00986 int j;
00987 size_t k;
00988 schar value[MAX_NELS];
00989 nc_type datatype;
00990 double expect[MAX_NELS];
00991 size_t length;
00992 size_t nInExtRange;
00993 size_t nInIntRange;
00994 int canConvert;
00995 int nok = 0;
00996
00997 for (i = -1; i < NVARS; i++) {
00998 for (j = 0; j < NATTS(i); j++) {
00999 canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
01000 if (canConvert) {
01001 err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);
01002 IF (err)
01003 error("nc_inq_att: %s", nc_strerror(err));
01004 IF (datatype != ATT_TYPE(i,j))
01005 error("nc_inq_att: unexpected type");
01006 IF (length != ATT_LEN(i,j))
01007 error("nc_inq_att: unexpected length");
01008 assert(length <= MAX_NELS);
01009 nInIntRange = nInExtRange = 0;
01010 for (k = 0; k < length; k++) {
01011 expect[k] = hash4( datatype, -1, &k, NCT_SCHAR);
01012 if (inRange3(expect[k], datatype, NCT_SCHAR)) {
01013 ++nInExtRange;
01014 if (expect[k] >= schar_min && expect[k] <= schar_max)
01015 ++nInIntRange;
01016 }
01017 }
01018 err = nc_get_att_schar(ncid, i, ATT_NAME(i,j), value);
01019 if (nInExtRange == length && nInIntRange == length) {
01020 IF (err)
01021 error("%s", nc_strerror(err));
01022 } else {
01023 IF (err != 0 && err != NC_ERANGE)
01024 error("OK or Range error: status = %d", err);
01025 }
01026 for (k = 0; k < length; k++) {
01027 if (inRange3(expect[k],datatype,NCT_SCHAR)
01028 && expect[k] >= schar_min && expect[k] <= schar_max) {
01029 IF (!equal(value[k],expect[k],datatype,NCT_SCHAR)) {
01030 error("att. value read not that expected");
01031 if (verbose) {
01032 error("\n");
01033 error("varid: %d, ", i);
01034 error("att_name: %s, ", ATT_NAME(i,j));
01035 error("element number: %d ", k);
01036 error("expect: %g, ", expect[k]);
01037 error("got: %g", (double) value[k]);
01038 }
01039 } else {
01040 nok++;
01041 }
01042 }
01043 }
01044 }
01045 }
01046 }
01047
01048 print_nok(nok);
01049 }
01050
01051
01052
01053
01054
01055 static
01056 void
01057 check_atts_short(int ncid)
01058 {
01059 int err;
01060 int i;
01061 int j;
01062 size_t k;
01063 short value[MAX_NELS];
01064 nc_type datatype;
01065 double expect[MAX_NELS];
01066 size_t length;
01067 size_t nInExtRange;
01068 size_t nInIntRange;
01069 int canConvert;
01070 int nok = 0;
01071
01072 for (i = -1; i < NVARS; i++) {
01073 for (j = 0; j < NATTS(i); j++) {
01074 canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
01075 if (canConvert) {
01076 err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);
01077 IF (err)
01078 error("nc_inq_att: %s", nc_strerror(err));
01079 IF (datatype != ATT_TYPE(i,j))
01080 error("nc_inq_att: unexpected type");
01081 IF (length != ATT_LEN(i,j))
01082 error("nc_inq_att: unexpected length");
01083 assert(length <= MAX_NELS);
01084 nInIntRange = nInExtRange = 0;
01085 for (k = 0; k < length; k++) {
01086 expect[k] = hash4( datatype, -1, &k, NCT_SHORT);
01087 if (inRange3(expect[k], datatype, NCT_SHORT)) {
01088 ++nInExtRange;
01089 if (expect[k] >= short_min && expect[k] <= short_max)
01090 ++nInIntRange;
01091 }
01092 }
01093 err = nc_get_att_short(ncid, i, ATT_NAME(i,j), value);
01094 if (nInExtRange == length && nInIntRange == length) {
01095 IF (err)
01096 error("%s", nc_strerror(err));
01097 } else {
01098 IF (err != 0 && err != NC_ERANGE)
01099 error("OK or Range error: status = %d", err);
01100 }
01101 for (k = 0; k < length; k++) {
01102 if (inRange3(expect[k],datatype,NCT_SHORT)
01103 && expect[k] >= short_min && expect[k] <= short_max) {
01104 IF (!equal(value[k],expect[k],datatype,NCT_SHORT)) {
01105 error("att. value read not that expected");
01106 if (verbose) {
01107 error("\n");
01108 error("varid: %d, ", i);
01109 error("att_name: %s, ", ATT_NAME(i,j));
01110 error("element number: %d ", k);
01111 error("expect: %g, ", expect[k]);
01112 error("got: %g", (double) value[k]);
01113 }
01114 } else {
01115 nok++;
01116 }
01117 }
01118 }
01119 }
01120 }
01121 }
01122
01123 print_nok(nok);
01124 }
01125
01126
01127
01128
01129
01130 static
01131 void
01132 check_atts_int(int ncid)
01133 {
01134 int err;
01135 int i;
01136 int j;
01137 size_t k;
01138 int value[MAX_NELS];
01139 nc_type datatype;
01140 double expect[MAX_NELS];
01141 size_t length;
01142 size_t nInExtRange;
01143 size_t nInIntRange;
01144 int canConvert;
01145 int nok = 0;
01146
01147 for (i = -1; i < NVARS; i++) {
01148 for (j = 0; j < NATTS(i); j++) {
01149 canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_INT == NCT_TEXT);
01150 if (canConvert) {
01151 err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);
01152 IF (err)
01153 error("nc_inq_att: %s", nc_strerror(err));
01154 IF (datatype != ATT_TYPE(i,j))
01155 error("nc_inq_att: unexpected type");
01156 IF (length != ATT_LEN(i,j))
01157 error("nc_inq_att: unexpected length");
01158 assert(length <= MAX_NELS);
01159 nInIntRange = nInExtRange = 0;
01160 for (k = 0; k < length; k++) {
01161 expect[k] = hash4( datatype, -1, &k, NCT_INT);
01162 if (inRange3(expect[k], datatype, NCT_INT)) {
01163 ++nInExtRange;
01164 if (expect[k] >= int_min && expect[k] <= int_max)
01165 ++nInIntRange;
01166 }
01167 }
01168 err = nc_get_att_int(ncid, i, ATT_NAME(i,j), value);
01169 if (nInExtRange == length && nInIntRange == length) {
01170 IF (err)
01171 error("%s", nc_strerror(err));
01172 } else {
01173 IF (err != 0 && err != NC_ERANGE)
01174 error("OK or Range error: status = %d", err);
01175 }
01176 for (k = 0; k < length; k++) {
01177 if (inRange3(expect[k],datatype,NCT_INT)
01178 && expect[k] >= int_min && expect[k] <= int_max) {
01179 IF (!equal(value[k],expect[k],datatype,NCT_INT)) {
01180 error("att. value read not that expected");
01181 if (verbose) {
01182 error("\n");
01183 error("varid: %d, ", i);
01184 error("att_name: %s, ", ATT_NAME(i,j));
01185 error("element number: %d ", k);
01186 error("expect: %g, ", expect[k]);
01187 error("got: %g", (double) value[k]);
01188 }
01189 } else {
01190 nok++;
01191 }
01192 }
01193 }
01194 }
01195 }
01196 }
01197
01198 print_nok(nok);
01199 }
01200
01201
01202
01203
01204
01205 static
01206 void
01207 check_atts_long(int ncid)
01208 {
01209 int err;
01210 int i;
01211 int j;
01212 size_t k;
01213 long value[MAX_NELS];
01214 nc_type datatype;
01215 double expect[MAX_NELS];
01216 size_t length;
01217 size_t nInExtRange;
01218 size_t nInIntRange;
01219 int canConvert;
01220 int nok = 0;
01221
01222 for (i = -1; i < NVARS; i++) {
01223 for (j = 0; j < NATTS(i); j++) {
01224 canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_LONG == NCT_TEXT);
01225 if (canConvert) {
01226 err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);
01227 IF (err)
01228 error("nc_inq_att: %s", nc_strerror(err));
01229 IF (datatype != ATT_TYPE(i,j))
01230 error("nc_inq_att: unexpected type");
01231 IF (length != ATT_LEN(i,j))
01232 error("nc_inq_att: unexpected length");
01233 assert(length <= MAX_NELS);
01234 nInIntRange = nInExtRange = 0;
01235 for (k = 0; k < length; k++) {
01236 expect[k] = hash4( datatype, -1, &k, NCT_LONG);
01237 if (inRange3(expect[k], datatype, NCT_LONG)) {
01238 ++nInExtRange;
01239 if (expect[k] >= long_min && expect[k] <= long_max)
01240 ++nInIntRange;
01241 }
01242 }
01243 err = nc_get_att_long(ncid, i, ATT_NAME(i,j), value);
01244 if (nInExtRange == length && nInIntRange == length) {
01245 IF (err)
01246 error("%s", nc_strerror(err));
01247 } else {
01248 IF (err != 0 && err != NC_ERANGE)
01249 error("OK or Range error: status = %d", err);
01250 }
01251 for (k = 0; k < length; k++) {
01252 if (inRange3(expect[k],datatype,NCT_LONG)
01253 && expect[k] >= long_min && expect[k] <= long_max) {
01254 IF (!equal(value[k],expect[k],datatype,NCT_LONG)) {
01255 error("att. value read not that expected");
01256 if (verbose) {
01257 error("\n");
01258 error("varid: %d, ", i);
01259 error("att_name: %s, ", ATT_NAME(i,j));
01260 error("element number: %d ", k);
01261 error("expect: %g, ", expect[k]);
01262 error("got: %g", (double) value[k]);
01263 }
01264 } else {
01265 nok++;
01266 }
01267 }
01268 }
01269 }
01270 }
01271 }
01272
01273 print_nok(nok);
01274 }
01275
01276
01277
01278
01279
01280 static
01281 void
01282 check_atts_float(int ncid)
01283 {
01284 int err;
01285 int i;
01286 int j;
01287 size_t k;
01288 float value[MAX_NELS];
01289 nc_type datatype;
01290 double expect[MAX_NELS];
01291 size_t length;
01292 size_t nInExtRange;
01293 size_t nInIntRange;
01294 int canConvert;
01295 int nok = 0;
01296
01297 for (i = -1; i < NVARS; i++) {
01298 for (j = 0; j < NATTS(i); j++) {
01299 canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
01300 if (canConvert) {
01301 err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);
01302 IF (err)
01303 error("nc_inq_att: %s", nc_strerror(err));
01304 IF (datatype != ATT_TYPE(i,j))
01305 error("nc_inq_att: unexpected type");
01306 IF (length != ATT_LEN(i,j))
01307 error("nc_inq_att: unexpected length");
01308 assert(length <= MAX_NELS);
01309 nInIntRange = nInExtRange = 0;
01310 for (k = 0; k < length; k++) {
01311 expect[k] = hash4( datatype, -1, &k, NCT_FLOAT);
01312 if (inRange3(expect[k], datatype, NCT_FLOAT)) {
01313 ++nInExtRange;
01314 if (expect[k] >= float_min && expect[k] <= float_max)
01315 ++nInIntRange;
01316 }
01317 }
01318 err = nc_get_att_float(ncid, i, ATT_NAME(i,j), value);
01319 if (nInExtRange == length && nInIntRange == length) {
01320 IF (err)
01321 error("%s", nc_strerror(err));
01322 } else {
01323 IF (err != 0 && err != NC_ERANGE)
01324 error("OK or Range error: status = %d", err);
01325 }
01326 for (k = 0; k < length; k++) {
01327 if (inRange3(expect[k],datatype,NCT_FLOAT)
01328 && expect[k] >= float_min && expect[k] <= float_max) {
01329 IF (!equal(value[k],expect[k],datatype,NCT_FLOAT)) {
01330 error("att. value read not that expected");
01331 if (verbose) {
01332 error("\n");
01333 error("varid: %d, ", i);
01334 error("att_name: %s, ", ATT_NAME(i,j));
01335 error("element number: %d ", k);
01336 error("expect: %g, ", expect[k]);
01337 error("got: %g", (double) value[k]);
01338 }
01339 } else {
01340 nok++;
01341 }
01342 }
01343 }
01344 }
01345 }
01346 }
01347
01348 print_nok(nok);
01349 }
01350
01351
01352
01353
01354
01355 static
01356 void
01357 check_atts_double(int ncid)
01358 {
01359 int err;
01360 int i;
01361 int j;
01362 size_t k;
01363 double value[MAX_NELS];
01364 nc_type datatype;
01365 double expect[MAX_NELS];
01366 size_t length;
01367 size_t nInExtRange;
01368 size_t nInIntRange;
01369 int canConvert;
01370 int nok = 0;
01371
01372 for (i = -1; i < NVARS; i++) {
01373 for (j = 0; j < NATTS(i); j++) {
01374 canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
01375 if (canConvert) {
01376 err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);
01377 IF (err)
01378 error("nc_inq_att: %s", nc_strerror(err));
01379 IF (datatype != ATT_TYPE(i,j))
01380 error("nc_inq_att: unexpected type");
01381 IF (length != ATT_LEN(i,j))
01382 error("nc_inq_att: unexpected length");
01383 assert(length <= MAX_NELS);
01384 nInIntRange = nInExtRange = 0;
01385 for (k = 0; k < length; k++) {
01386 expect[k] = hash4( datatype, -1, &k, NCT_DOUBLE);
01387 if (inRange3(expect[k], datatype, NCT_DOUBLE)) {
01388 ++nInExtRange;
01389 if (expect[k] >= double_min && expect[k] <= double_max)
01390 ++nInIntRange;
01391 }
01392 }
01393 err = nc_get_att_double(ncid, i, ATT_NAME(i,j), value);
01394 if (nInExtRange == length && nInIntRange == length) {
01395 IF (err)
01396 error("%s", nc_strerror(err));
01397 } else {
01398 IF (err != 0 && err != NC_ERANGE)
01399 error("OK or Range error: status = %d", err);
01400 }
01401 for (k = 0; k < length; k++) {
01402 if (inRange3(expect[k],datatype,NCT_DOUBLE)
01403 && expect[k] >= double_min && expect[k] <= double_max) {
01404 IF (!equal(value[k],expect[k],datatype,NCT_DOUBLE)) {
01405 error("att. value read not that expected");
01406 if (verbose) {
01407 error("\n");
01408 error("varid: %d, ", i);
01409 error("att_name: %s, ", ATT_NAME(i,j));
01410 error("element number: %d ", k);
01411 error("expect: %g, ", expect[k]);
01412 error("got: %g", (double) value[k]);
01413 }
01414 } else {
01415 nok++;
01416 }
01417 }
01418 }
01419 }
01420 }
01421 }
01422
01423 print_nok(nok);
01424 }
01425
01426
01427
01428
01429 void
01430 test_nc_put_var1_text(void)
01431 {
01432 int ncid;
01433 int i;
01434 int j;
01435 int err;
01436 size_t index[MAX_RANK];
01437 int canConvert;
01438 text value = 5;
01439
01440 err = nc_create(scratch, NC_CLOBBER, &ncid);
01441 IF (err) {
01442 error("nc_create: %s", nc_strerror(err));
01443 return;
01444 }
01445 def_dims(ncid);
01446 def_vars(ncid);
01447 err = nc_enddef(ncid);
01448 IF (err)
01449 error("nc_enddef: %s", nc_strerror(err));
01450
01451 for (i = 0; i < NVARS; i++) {
01452 canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
01453 for (j = 0; j < var_rank[i]; j++)
01454 index[j] = 0;
01455 err = nc_put_var1_text(BAD_ID, i, index, &value);
01456 IF (err != NC_EBADID)
01457 error("bad ncid: status = %d", err);
01458 err = nc_put_var1_text(ncid, BAD_VARID, index, &value);
01459 IF (err != NC_ENOTVAR)
01460 error("bad var id: status = %d", err);
01461 for (j = 0; j < var_rank[i]; j++) {
01462 if (var_dimid[i][j] > 0) {
01463 index[j] = var_shape[i][j];
01464 err = nc_put_var1_text(ncid, i, index, &value);
01465 IF (canConvert && err != NC_EINVALCOORDS)
01466 error("bad index: status = %d", err);
01467 index[j] = 0;
01468 }
01469 }
01470 for (j = 0; j < var_nels[i]; j++) {
01471 err = toMixedBase(j, var_rank[i], var_shape[i], index);
01472 IF (err)
01473 error("error in toMixedBase 1");
01474 value = hash_text( var_type[i], var_rank[i], index, NCT_TEXT);
01475 if (var_rank[i] == 0 && i%2 == 0)
01476 err = nc_put_var1_text(ncid, i, NULL, &value);
01477 else
01478 err = nc_put_var1_text(ncid, i, index, &value);
01479 if (canConvert) {
01480 if (inRange3(value, var_type[i],NCT_TEXT)) {
01481 IF (err)
01482 error("%s", nc_strerror(err));
01483 } else {
01484 IF (err != NC_ERANGE) {
01485 error("Range error: status = %d", err);
01486 error("\n\t\tfor type %s value %.17e %ld",
01487 s_nc_type(var_type[i]),
01488 (double)value, (long)value);
01489 }
01490 }
01491 } else {
01492 IF (err != NC_ECHAR)
01493 error("wrong type: status = %d", err);
01494 }
01495 }
01496 }
01497
01498 err = nc_close(ncid);
01499 IF (err)
01500 error("nc_close: %s", nc_strerror(err));
01501
01502 check_vars_text(scratch);
01503
01504 err = remove(scratch);
01505 IF (err)
01506 error("remove of %s failed", scratch);
01507 }
01508
01509 void
01510 test_nc_put_var1_uchar(void)
01511 {
01512 int ncid;
01513 int i;
01514 int j;
01515 int err;
01516 size_t index[MAX_RANK];
01517 int canConvert;
01518 uchar value = 5;
01519
01520 err = nc_create(scratch, NC_CLOBBER, &ncid);
01521 IF (err) {
01522 error("nc_create: %s", nc_strerror(err));
01523 return;
01524 }
01525 def_dims(ncid);
01526 def_vars(ncid);
01527 err = nc_enddef(ncid);
01528 IF (err)
01529 error("nc_enddef: %s", nc_strerror(err));
01530
01531 for (i = 0; i < NVARS; i++) {
01532 canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
01533 for (j = 0; j < var_rank[i]; j++)
01534 index[j] = 0;
01535 err = nc_put_var1_uchar(BAD_ID, i, index, &value);
01536 IF (err != NC_EBADID)
01537 error("bad ncid: status = %d", err);
01538 err = nc_put_var1_uchar(ncid, BAD_VARID, index, &value);
01539 IF (err != NC_ENOTVAR)
01540 error("bad var id: status = %d", err);
01541 for (j = 0; j < var_rank[i]; j++) {
01542 if (var_dimid[i][j] > 0) {
01543 index[j] = var_shape[i][j];
01544 err = nc_put_var1_uchar(ncid, i, index, &value);
01545 IF (canConvert && err != NC_EINVALCOORDS)
01546 error("bad index: status = %d", err);
01547 index[j] = 0;
01548 }
01549 }
01550 for (j = 0; j < var_nels[i]; j++) {
01551 err = toMixedBase(j, var_rank[i], var_shape[i], index);
01552 IF (err)
01553 error("error in toMixedBase 1");
01554 value = hash_uchar( var_type[i], var_rank[i], index, NCT_UCHAR);
01555 if (var_rank[i] == 0 && i%2 == 0)
01556 err = nc_put_var1_uchar(ncid, i, NULL, &value);
01557 else
01558 err = nc_put_var1_uchar(ncid, i, index, &value);
01559 if (canConvert) {
01560 if (inRange3(value, var_type[i],NCT_UCHAR)) {
01561 IF (err)
01562 error("%s", nc_strerror(err));
01563 } else {
01564 IF (err != NC_ERANGE) {
01565 error("Range error: status = %d", err);
01566 error("\n\t\tfor type %s value %.17e %ld",
01567 s_nc_type(var_type[i]),
01568 (double)value, (long)value);
01569 }
01570 }
01571 } else {
01572 IF (err != NC_ECHAR)
01573 error("wrong type: status = %d", err);
01574 }
01575 }
01576 }
01577
01578 err = nc_close(ncid);
01579 IF (err)
01580 error("nc_close: %s", nc_strerror(err));
01581
01582 check_vars_uchar(scratch);
01583
01584 err = remove(scratch);
01585 IF (err)
01586 error("remove of %s failed", scratch);
01587 }
01588
01589 void
01590 test_nc_put_var1_schar(void)
01591 {
01592 int ncid;
01593 int i;
01594 int j;
01595 int err;
01596 size_t index[MAX_RANK];
01597 int canConvert;
01598 schar value = 5;
01599
01600 err = nc_create(scratch, NC_CLOBBER, &ncid);
01601 IF (err) {
01602 error("nc_create: %s", nc_strerror(err));
01603 return;
01604 }
01605 def_dims(ncid);
01606 def_vars(ncid);
01607 err = nc_enddef(ncid);
01608 IF (err)
01609 error("nc_enddef: %s", nc_strerror(err));
01610
01611 for (i = 0; i < NVARS; i++) {
01612 canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
01613 for (j = 0; j < var_rank[i]; j++)
01614 index[j] = 0;
01615 err = nc_put_var1_schar(BAD_ID, i, index, &value);
01616 IF (err != NC_EBADID)
01617 error("bad ncid: status = %d", err);
01618 err = nc_put_var1_schar(ncid, BAD_VARID, index, &value);
01619 IF (err != NC_ENOTVAR)
01620 error("bad var id: status = %d", err);
01621 for (j = 0; j < var_rank[i]; j++) {
01622 if (var_dimid[i][j] > 0) {
01623 index[j] = var_shape[i][j];
01624 err = nc_put_var1_schar(ncid, i, index, &value);
01625 IF (canConvert && err != NC_EINVALCOORDS)
01626 error("bad index: status = %d", err);
01627 index[j] = 0;
01628 }
01629 }
01630 for (j = 0; j < var_nels[i]; j++) {
01631 err = toMixedBase(j, var_rank[i], var_shape[i], index);
01632 IF (err)
01633 error("error in toMixedBase 1");
01634 value = hash_schar( var_type[i], var_rank[i], index, NCT_SCHAR);
01635 if (var_rank[i] == 0 && i%2 == 0)
01636 err = nc_put_var1_schar(ncid, i, NULL, &value);
01637 else
01638 err = nc_put_var1_schar(ncid, i, index, &value);
01639 if (canConvert) {
01640 if (inRange3(value, var_type[i],NCT_SCHAR)) {
01641 IF (err)
01642 error("%s", nc_strerror(err));
01643 } else {
01644 IF (err != NC_ERANGE) {
01645 error("Range error: status = %d", err);
01646 error("\n\t\tfor type %s value %.17e %ld",
01647 s_nc_type(var_type[i]),
01648 (double)value, (long)value);
01649 }
01650 }
01651 } else {
01652 IF (err != NC_ECHAR)
01653 error("wrong type: status = %d", err);
01654 }
01655 }
01656 }
01657
01658 err = nc_close(ncid);
01659 IF (err)
01660 error("nc_close: %s", nc_strerror(err));
01661
01662 check_vars_schar(scratch);
01663
01664 err = remove(scratch);
01665 IF (err)
01666 error("remove of %s failed", scratch);
01667 }
01668
01669 void
01670 test_nc_put_var1_short(void)
01671 {
01672 int ncid;
01673 int i;
01674 int j;
01675 int err;
01676 size_t index[MAX_RANK];
01677 int canConvert;
01678 short value = 5;
01679
01680 err = nc_create(scratch, NC_CLOBBER, &ncid);
01681 IF (err) {
01682 error("nc_create: %s", nc_strerror(err));
01683 return;
01684 }
01685 def_dims(ncid);
01686 def_vars(ncid);
01687 err = nc_enddef(ncid);
01688 IF (err)
01689 error("nc_enddef: %s", nc_strerror(err));
01690
01691 for (i = 0; i < NVARS; i++) {
01692 canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
01693 for (j = 0; j < var_rank[i]; j++)
01694 index[j] = 0;
01695 err = nc_put_var1_short(BAD_ID, i, index, &value);
01696 IF (err != NC_EBADID)
01697 error("bad ncid: status = %d", err);
01698 err = nc_put_var1_short(ncid, BAD_VARID, index, &value);
01699 IF (err != NC_ENOTVAR)
01700 error("bad var id: status = %d", err);
01701 for (j = 0; j < var_rank[i]; j++) {
01702 if (var_dimid[i][j] > 0) {
01703 index[j] = var_shape[i][j];
01704 err = nc_put_var1_short(ncid, i, index, &value);
01705 IF (canConvert && err != NC_EINVALCOORDS)
01706 error("bad index: status = %d", err);
01707 index[j] = 0;
01708 }
01709 }
01710 for (j = 0; j < var_nels[i]; j++) {
01711 err = toMixedBase(j, var_rank[i], var_shape[i], index);
01712 IF (err)
01713 error("error in toMixedBase 1");
01714 value = hash_short( var_type[i], var_rank[i], index, NCT_SHORT);
01715 if (var_rank[i] == 0 && i%2 == 0)
01716 err = nc_put_var1_short(ncid, i, NULL, &value);
01717 else
01718 err = nc_put_var1_short(ncid, i, index, &value);
01719 if (canConvert) {
01720 if (inRange3(value, var_type[i],NCT_SHORT)) {
01721 IF (err)
01722 error("%s", nc_strerror(err));
01723 } else {
01724 IF (err != NC_ERANGE) {
01725 error("Range error: status = %d", err);
01726 error("\n\t\tfor type %s value %.17e %ld",
01727 s_nc_type(var_type[i]),
01728 (double)value, (long)value);
01729 }
01730 }
01731 } else {
01732 IF (err != NC_ECHAR)
01733 error("wrong type: status = %d", err);
01734 }
01735 }
01736 }
01737
01738 err = nc_close(ncid);
01739 IF (err)
01740 error("nc_close: %s", nc_strerror(err));
01741
01742 check_vars_short(scratch);
01743
01744 err = remove(scratch);
01745 IF (err)
01746 error("remove of %s failed", scratch);
01747 }
01748
01749 void
01750 test_nc_put_var1_int(void)
01751 {
01752 int ncid;
01753 int i;
01754 int j;
01755 int err;
01756 size_t index[MAX_RANK];
01757 int canConvert;
01758 int value = 5;
01759
01760 err = nc_create(scratch, NC_CLOBBER, &ncid);
01761 IF (err) {
01762 error("nc_create: %s", nc_strerror(err));
01763 return;
01764 }
01765 def_dims(ncid);
01766 def_vars(ncid);
01767 err = nc_enddef(ncid);
01768 IF (err)
01769 error("nc_enddef: %s", nc_strerror(err));
01770
01771 for (i = 0; i < NVARS; i++) {
01772 canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
01773 for (j = 0; j < var_rank[i]; j++)
01774 index[j] = 0;
01775 err = nc_put_var1_int(BAD_ID, i, index, &value);
01776 IF (err != NC_EBADID)
01777 error("bad ncid: status = %d", err);
01778 err = nc_put_var1_int(ncid, BAD_VARID, index, &value);
01779 IF (err != NC_ENOTVAR)
01780 error("bad var id: status = %d", err);
01781 for (j = 0; j < var_rank[i]; j++) {
01782 if (var_dimid[i][j] > 0) {
01783 index[j] = var_shape[i][j];
01784 err = nc_put_var1_int(ncid, i, index, &value);
01785 IF (canConvert && err != NC_EINVALCOORDS)
01786 error("bad index: status = %d", err);
01787 index[j] = 0;
01788 }
01789 }
01790 for (j = 0; j < var_nels[i]; j++) {
01791 err = toMixedBase(j, var_rank[i], var_shape[i], index);
01792 IF (err)
01793 error("error in toMixedBase 1");
01794 value = hash_int( var_type[i], var_rank[i], index, NCT_INT);
01795 if (var_rank[i] == 0 && i%2 == 0)
01796 err = nc_put_var1_int(ncid, i, NULL, &value);
01797 else
01798 err = nc_put_var1_int(ncid, i, index, &value);
01799 if (canConvert) {
01800 if (inRange3(value, var_type[i],NCT_INT)) {
01801 IF (err)
01802 error("%s", nc_strerror(err));
01803 } else {
01804 IF (err != NC_ERANGE) {
01805 error("Range error: status = %d", err);
01806 error("\n\t\tfor type %s value %.17e %ld",
01807 s_nc_type(var_type[i]),
01808 (double)value, (long)value);
01809 }
01810 }
01811 } else {
01812 IF (err != NC_ECHAR)
01813 error("wrong type: status = %d", err);
01814 }
01815 }
01816 }
01817
01818 err = nc_close(ncid);
01819 IF (err)
01820 error("nc_close: %s", nc_strerror(err));
01821
01822 check_vars_int(scratch);
01823
01824 err = remove(scratch);
01825 IF (err)
01826 error("remove of %s failed", scratch);
01827 }
01828
01829 void
01830 test_nc_put_var1_long(void)
01831 {
01832 int ncid;
01833 int i;
01834 int j;
01835 int err;
01836 size_t index[MAX_RANK];
01837 int canConvert;
01838 long value = 5;
01839
01840 err = nc_create(scratch, NC_CLOBBER, &ncid);
01841 IF (err) {
01842 error("nc_create: %s", nc_strerror(err));
01843 return;
01844 }
01845 def_dims(ncid);
01846 def_vars(ncid);
01847 err = nc_enddef(ncid);
01848 IF (err)
01849 error("nc_enddef: %s", nc_strerror(err));
01850
01851 for (i = 0; i < NVARS; i++) {
01852 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
01853 for (j = 0; j < var_rank[i]; j++)
01854 index[j] = 0;
01855 err = nc_put_var1_long(BAD_ID, i, index, &value);
01856 IF (err != NC_EBADID)
01857 error("bad ncid: status = %d", err);
01858 err = nc_put_var1_long(ncid, BAD_VARID, index, &value);
01859 IF (err != NC_ENOTVAR)
01860 error("bad var id: status = %d", err);
01861 for (j = 0; j < var_rank[i]; j++) {
01862 if (var_dimid[i][j] > 0) {
01863 index[j] = var_shape[i][j];
01864 err = nc_put_var1_long(ncid, i, index, &value);
01865 IF (canConvert && err != NC_EINVALCOORDS)
01866 error("bad index: status = %d", err);
01867 index[j] = 0;
01868 }
01869 }
01870 for (j = 0; j < var_nels[i]; j++) {
01871 err = toMixedBase(j, var_rank[i], var_shape[i], index);
01872 IF (err)
01873 error("error in toMixedBase 1");
01874 value = hash_long( var_type[i], var_rank[i], index, NCT_LONG);
01875 if (var_rank[i] == 0 && i%2 == 0)
01876 err = nc_put_var1_long(ncid, i, NULL, &value);
01877 else
01878 err = nc_put_var1_long(ncid, i, index, &value);
01879 if (canConvert) {
01880 if (inRange3(value, var_type[i],NCT_LONG)) {
01881 IF (err)
01882 error("%s", nc_strerror(err));
01883 } else {
01884 IF (err != NC_ERANGE) {
01885 error("Range error: status = %d", err);
01886 error("\n\t\tfor type %s value %.17e %ld",
01887 s_nc_type(var_type[i]),
01888 (double)value, (long)value);
01889 }
01890 }
01891 } else {
01892 IF (err != NC_ECHAR)
01893 error("wrong type: status = %d", err);
01894 }
01895 }
01896 }
01897
01898 err = nc_close(ncid);
01899 IF (err)
01900 error("nc_close: %s", nc_strerror(err));
01901
01902 check_vars_long(scratch);
01903
01904 err = remove(scratch);
01905 IF (err)
01906 error("remove of %s failed", scratch);
01907 }
01908
01909 void
01910 test_nc_put_var1_float(void)
01911 {
01912 int ncid;
01913 int i;
01914 int j;
01915 int err;
01916 size_t index[MAX_RANK];
01917 int canConvert;
01918 float value = 5;
01919
01920 err = nc_create(scratch, NC_CLOBBER, &ncid);
01921 IF (err) {
01922 error("nc_create: %s", nc_strerror(err));
01923 return;
01924 }
01925 def_dims(ncid);
01926 def_vars(ncid);
01927 err = nc_enddef(ncid);
01928 IF (err)
01929 error("nc_enddef: %s", nc_strerror(err));
01930
01931 for (i = 0; i < NVARS; i++) {
01932 canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
01933 for (j = 0; j < var_rank[i]; j++)
01934 index[j] = 0;
01935 err = nc_put_var1_float(BAD_ID, i, index, &value);
01936 IF (err != NC_EBADID)
01937 error("bad ncid: status = %d", err);
01938 err = nc_put_var1_float(ncid, BAD_VARID, index, &value);
01939 IF (err != NC_ENOTVAR)
01940 error("bad var id: status = %d", err);
01941 for (j = 0; j < var_rank[i]; j++) {
01942 if (var_dimid[i][j] > 0) {
01943 index[j] = var_shape[i][j];
01944 err = nc_put_var1_float(ncid, i, index, &value);
01945 IF (canConvert && err != NC_EINVALCOORDS)
01946 error("bad index: status = %d", err);
01947 index[j] = 0;
01948 }
01949 }
01950 for (j = 0; j < var_nels[i]; j++) {
01951 err = toMixedBase(j, var_rank[i], var_shape[i], index);
01952 IF (err)
01953 error("error in toMixedBase 1");
01954 value = hash_float( var_type[i], var_rank[i], index, NCT_FLOAT);
01955 if (var_rank[i] == 0 && i%2 == 0)
01956 err = nc_put_var1_float(ncid, i, NULL, &value);
01957 else
01958 err = nc_put_var1_float(ncid, i, index, &value);
01959 if (canConvert) {
01960 if (inRange3(value, var_type[i],NCT_FLOAT)) {
01961 IF (err)
01962 error("%s", nc_strerror(err));
01963 } else {
01964 IF (err != NC_ERANGE) {
01965 error("Range error: status = %d", err);
01966 error("\n\t\tfor type %s value %.17e %ld",
01967 s_nc_type(var_type[i]),
01968 (double)value, (long)value);
01969 }
01970 }
01971 } else {
01972 IF (err != NC_ECHAR)
01973 error("wrong type: status = %d", err);
01974 }
01975 }
01976 }
01977
01978 err = nc_close(ncid);
01979 IF (err)
01980 error("nc_close: %s", nc_strerror(err));
01981
01982 check_vars_float(scratch);
01983
01984 err = remove(scratch);
01985 IF (err)
01986 error("remove of %s failed", scratch);
01987 }
01988
01989 void
01990 test_nc_put_var1_double(void)
01991 {
01992 int ncid;
01993 int i;
01994 int j;
01995 int err;
01996 size_t index[MAX_RANK];
01997 int canConvert;
01998 double value = 5;
01999
02000 err = nc_create(scratch, NC_CLOBBER, &ncid);
02001 IF (err) {
02002 error("nc_create: %s", nc_strerror(err));
02003 return;
02004 }
02005 def_dims(ncid);
02006 def_vars(ncid);
02007 err = nc_enddef(ncid);
02008 IF (err)
02009 error("nc_enddef: %s", nc_strerror(err));
02010
02011 for (i = 0; i < NVARS; i++) {
02012 canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
02013 for (j = 0; j < var_rank[i]; j++)
02014 index[j] = 0;
02015 err = nc_put_var1_double(BAD_ID, i, index, &value);
02016 IF (err != NC_EBADID)
02017 error("bad ncid: status = %d", err);
02018 err = nc_put_var1_double(ncid, BAD_VARID, index, &value);
02019 IF (err != NC_ENOTVAR)
02020 error("bad var id: status = %d", err);
02021 for (j = 0; j < var_rank[i]; j++) {
02022 if (var_dimid[i][j] > 0) {
02023 index[j] = var_shape[i][j];
02024 err = nc_put_var1_double(ncid, i, index, &value);
02025 IF (canConvert && err != NC_EINVALCOORDS)
02026 error("bad index: status = %d", err);
02027 index[j] = 0;
02028 }
02029 }
02030 for (j = 0; j < var_nels[i]; j++) {
02031 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02032 IF (err)
02033 error("error in toMixedBase 1");
02034 value = hash_double( var_type[i], var_rank[i], index, NCT_DOUBLE);
02035 if (var_rank[i] == 0 && i%2 == 0)
02036 err = nc_put_var1_double(ncid, i, NULL, &value);
02037 else
02038 err = nc_put_var1_double(ncid, i, index, &value);
02039 if (canConvert) {
02040 if (inRange3(value, var_type[i],NCT_DOUBLE)) {
02041 IF (err)
02042 error("%s", nc_strerror(err));
02043 } else {
02044 IF (err != NC_ERANGE) {
02045 error("Range error: status = %d", err);
02046 error("\n\t\tfor type %s value %.17e %ld",
02047 s_nc_type(var_type[i]),
02048 (double)value, (long)value);
02049 }
02050 }
02051 } else {
02052 IF (err != NC_ECHAR)
02053 error("wrong type: status = %d", err);
02054 }
02055 }
02056 }
02057
02058 err = nc_close(ncid);
02059 IF (err)
02060 error("nc_close: %s", nc_strerror(err));
02061
02062 check_vars_double(scratch);
02063
02064 err = remove(scratch);
02065 IF (err)
02066 error("remove of %s failed", scratch);
02067 }
02068
02069
02070
02071
02072 void
02073 test_nc_put_var_text(void)
02074 {
02075 int ncid;
02076 int varid;
02077 int i;
02078 int j;
02079 int err;
02080 int nels;
02081 size_t index[MAX_RANK];
02082 int canConvert;
02083 int allInExtRange;
02084 text value[MAX_NELS];
02085
02086 err = nc_create(scratch, NC_CLOBBER, &ncid);
02087 IF (err) {
02088 error("nc_create: %s", nc_strerror(err));
02089 return;
02090 }
02091 def_dims(ncid);
02092 def_vars(ncid);
02093 err = nc_enddef(ncid);
02094 IF (err)
02095 error("nc_enddef: %s", nc_strerror(err));
02096
02097 for (i = 0; i < NVARS; i++) {
02098 canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
02099 assert(var_rank[i] <= MAX_RANK);
02100 assert(var_nels[i] <= MAX_NELS);
02101 err = nc_put_var_text(BAD_ID, i, value);
02102 IF (err != NC_EBADID)
02103 error("bad ncid: status = %d", err);
02104 err = nc_put_var_text(ncid, BAD_VARID, value);
02105 IF (err != NC_ENOTVAR)
02106 error("bad var id: status = %d", err);
02107
02108 nels = 1;
02109 for (j = 0; j < var_rank[i]; j++) {
02110 nels *= var_shape[i][j];
02111 }
02112 for (allInExtRange = 1, j = 0; j < nels; j++) {
02113 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02114 IF (err)
02115 error("error in toMixedBase 1");
02116 value[j]= hash_text(var_type[i], var_rank[i], index, NCT_TEXT);
02117 allInExtRange = allInExtRange
02118 && inRange3(value[j], var_type[i], NCT_TEXT);
02119 }
02120 err = nc_put_var_text(ncid, i, value);
02121 if (canConvert) {
02122 if (allInExtRange) {
02123 IF (err)
02124 error("%s", nc_strerror(err));
02125 } else {
02126 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
02127 error("range error: status = %d", err);
02128 }
02129 } else {
02130 IF (nels > 0 && err != NC_ECHAR)
02131 error("wrong type: status = %d", err);
02132 }
02133 }
02134
02135
02136
02137
02138
02139
02140 err = nc_inq_varid(ncid, "cr", &varid);
02141 IF (err)
02142 error("nc_inq_varid: %s", nc_strerror(err));
02143 index[0] = NRECS-1;
02144 err = nc_put_var1_text(ncid, varid, index, "x");
02145 IF (err)
02146 error("nc_put_var1_text: %s", nc_strerror(err));
02147
02148 for (i = 0; i < NVARS; i++) {
02149 if (var_dimid[i][0] == RECDIM) {
02150 canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
02151 assert(var_rank[i] <= MAX_RANK);
02152 assert(var_nels[i] <= MAX_NELS);
02153 err = nc_put_var_text(BAD_ID, i, value);
02154
02155 nels = 1;
02156 for (j = 0; j < var_rank[i]; j++) {
02157 nels *= var_shape[i][j];
02158 }
02159 for (allInExtRange = 1, j = 0; j < nels; j++) {
02160 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02161 IF (err)
02162 error("error in toMixedBase 1");
02163 value[j]= hash_text(var_type[i], var_rank[i], index, NCT_TEXT);
02164 allInExtRange = allInExtRange
02165 && inRange3(value[j], var_type[i], NCT_TEXT);
02166 }
02167 err = nc_put_var_text(ncid, i, value);
02168 if (canConvert) {
02169 if (allInExtRange) {
02170 IF (err)
02171 error("%s", nc_strerror(err));
02172 } else {
02173 IF (err != NC_ERANGE)
02174 error("range error: status = %d", err);
02175 }
02176 } else {
02177 IF (nels > 0 && err != NC_ECHAR)
02178 error("wrong type: status = %d", err);
02179 }
02180 }
02181 }
02182
02183 err = nc_close(ncid);
02184 IF (err)
02185 error("nc_close: %s", nc_strerror(err));
02186
02187 check_vars_text(scratch);
02188
02189 err = remove(scratch);
02190 IF (err)
02191 error("remove of %s failed", scratch);
02192 }
02193
02194 void
02195 test_nc_put_var_uchar(void)
02196 {
02197 int ncid;
02198 int varid;
02199 int i;
02200 int j;
02201 int err;
02202 int nels;
02203 size_t index[MAX_RANK];
02204 int canConvert;
02205 int allInExtRange;
02206 uchar value[MAX_NELS];
02207
02208 err = nc_create(scratch, NC_CLOBBER, &ncid);
02209 IF (err) {
02210 error("nc_create: %s", nc_strerror(err));
02211 return;
02212 }
02213 def_dims(ncid);
02214 def_vars(ncid);
02215 err = nc_enddef(ncid);
02216 IF (err)
02217 error("nc_enddef: %s", nc_strerror(err));
02218
02219 for (i = 0; i < NVARS; i++) {
02220 canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
02221 assert(var_rank[i] <= MAX_RANK);
02222 assert(var_nels[i] <= MAX_NELS);
02223 err = nc_put_var_uchar(BAD_ID, i, value);
02224 IF (err != NC_EBADID)
02225 error("bad ncid: status = %d", err);
02226 err = nc_put_var_uchar(ncid, BAD_VARID, value);
02227 IF (err != NC_ENOTVAR)
02228 error("bad var id: status = %d", err);
02229
02230 nels = 1;
02231 for (j = 0; j < var_rank[i]; j++) {
02232 nels *= var_shape[i][j];
02233 }
02234 for (allInExtRange = 1, j = 0; j < nels; j++) {
02235 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02236 IF (err)
02237 error("error in toMixedBase 1");
02238 value[j]= hash_uchar(var_type[i], var_rank[i], index, NCT_UCHAR);
02239 allInExtRange = allInExtRange
02240 && inRange3(value[j], var_type[i], NCT_UCHAR);
02241 }
02242 err = nc_put_var_uchar(ncid, i, value);
02243 if (canConvert) {
02244 if (allInExtRange) {
02245 IF (err)
02246 error("%s", nc_strerror(err));
02247 } else {
02248 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
02249 error("range error: status = %d", err);
02250 }
02251 } else {
02252 IF (nels > 0 && err != NC_ECHAR)
02253 error("wrong type: status = %d", err);
02254 }
02255 }
02256
02257
02258
02259
02260
02261
02262 err = nc_inq_varid(ncid, "cr", &varid);
02263 IF (err)
02264 error("nc_inq_varid: %s", nc_strerror(err));
02265 index[0] = NRECS-1;
02266 err = nc_put_var1_text(ncid, varid, index, "x");
02267 IF (err)
02268 error("nc_put_var1_text: %s", nc_strerror(err));
02269
02270 for (i = 0; i < NVARS; i++) {
02271 if (var_dimid[i][0] == RECDIM) {
02272 canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
02273 assert(var_rank[i] <= MAX_RANK);
02274 assert(var_nels[i] <= MAX_NELS);
02275 err = nc_put_var_uchar(BAD_ID, i, value);
02276
02277 nels = 1;
02278 for (j = 0; j < var_rank[i]; j++) {
02279 nels *= var_shape[i][j];
02280 }
02281 for (allInExtRange = 1, j = 0; j < nels; j++) {
02282 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02283 IF (err)
02284 error("error in toMixedBase 1");
02285 value[j]= hash_uchar(var_type[i], var_rank[i], index, NCT_UCHAR);
02286 allInExtRange = allInExtRange
02287 && inRange3(value[j], var_type[i], NCT_UCHAR);
02288 }
02289 err = nc_put_var_uchar(ncid, i, value);
02290 if (canConvert) {
02291 if (allInExtRange) {
02292 IF (err)
02293 error("%s", nc_strerror(err));
02294 } else {
02295 IF (err != NC_ERANGE)
02296 error("range error: status = %d", err);
02297 }
02298 } else {
02299 IF (nels > 0 && err != NC_ECHAR)
02300 error("wrong type: status = %d", err);
02301 }
02302 }
02303 }
02304
02305 err = nc_close(ncid);
02306 IF (err)
02307 error("nc_close: %s", nc_strerror(err));
02308
02309 check_vars_uchar(scratch);
02310
02311 err = remove(scratch);
02312 IF (err)
02313 error("remove of %s failed", scratch);
02314 }
02315
02316 void
02317 test_nc_put_var_schar(void)
02318 {
02319 int ncid;
02320 int varid;
02321 int i;
02322 int j;
02323 int err;
02324 int nels;
02325 size_t index[MAX_RANK];
02326 int canConvert;
02327 int allInExtRange;
02328 schar value[MAX_NELS];
02329
02330 err = nc_create(scratch, NC_CLOBBER, &ncid);
02331 IF (err) {
02332 error("nc_create: %s", nc_strerror(err));
02333 return;
02334 }
02335 def_dims(ncid);
02336 def_vars(ncid);
02337 err = nc_enddef(ncid);
02338 IF (err)
02339 error("nc_enddef: %s", nc_strerror(err));
02340
02341 for (i = 0; i < NVARS; i++) {
02342 canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
02343 assert(var_rank[i] <= MAX_RANK);
02344 assert(var_nels[i] <= MAX_NELS);
02345 err = nc_put_var_schar(BAD_ID, i, value);
02346 IF (err != NC_EBADID)
02347 error("bad ncid: status = %d", err);
02348 err = nc_put_var_schar(ncid, BAD_VARID, value);
02349 IF (err != NC_ENOTVAR)
02350 error("bad var id: status = %d", err);
02351
02352 nels = 1;
02353 for (j = 0; j < var_rank[i]; j++) {
02354 nels *= var_shape[i][j];
02355 }
02356 for (allInExtRange = 1, j = 0; j < nels; j++) {
02357 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02358 IF (err)
02359 error("error in toMixedBase 1");
02360 value[j]= hash_schar(var_type[i], var_rank[i], index, NCT_SCHAR);
02361 allInExtRange = allInExtRange
02362 && inRange3(value[j], var_type[i], NCT_SCHAR);
02363 }
02364 err = nc_put_var_schar(ncid, i, value);
02365 if (canConvert) {
02366 if (allInExtRange) {
02367 IF (err)
02368 error("%s", nc_strerror(err));
02369 } else {
02370 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
02371 error("range error: status = %d", err);
02372 }
02373 } else {
02374 IF (nels > 0 && err != NC_ECHAR)
02375 error("wrong type: status = %d", err);
02376 }
02377 }
02378
02379
02380
02381
02382
02383
02384 err = nc_inq_varid(ncid, "cr", &varid);
02385 IF (err)
02386 error("nc_inq_varid: %s", nc_strerror(err));
02387 index[0] = NRECS-1;
02388 err = nc_put_var1_text(ncid, varid, index, "x");
02389 IF (err)
02390 error("nc_put_var1_text: %s", nc_strerror(err));
02391
02392 for (i = 0; i < NVARS; i++) {
02393 if (var_dimid[i][0] == RECDIM) {
02394 canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
02395 assert(var_rank[i] <= MAX_RANK);
02396 assert(var_nels[i] <= MAX_NELS);
02397 err = nc_put_var_schar(BAD_ID, i, value);
02398
02399 nels = 1;
02400 for (j = 0; j < var_rank[i]; j++) {
02401 nels *= var_shape[i][j];
02402 }
02403 for (allInExtRange = 1, j = 0; j < nels; j++) {
02404 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02405 IF (err)
02406 error("error in toMixedBase 1");
02407 value[j]= hash_schar(var_type[i], var_rank[i], index, NCT_SCHAR);
02408 allInExtRange = allInExtRange
02409 && inRange3(value[j], var_type[i], NCT_SCHAR);
02410 }
02411 err = nc_put_var_schar(ncid, i, value);
02412 if (canConvert) {
02413 if (allInExtRange) {
02414 IF (err)
02415 error("%s", nc_strerror(err));
02416 } else {
02417 IF (err != NC_ERANGE)
02418 error("range error: status = %d", err);
02419 }
02420 } else {
02421 IF (nels > 0 && err != NC_ECHAR)
02422 error("wrong type: status = %d", err);
02423 }
02424 }
02425 }
02426
02427 err = nc_close(ncid);
02428 IF (err)
02429 error("nc_close: %s", nc_strerror(err));
02430
02431 check_vars_schar(scratch);
02432
02433 err = remove(scratch);
02434 IF (err)
02435 error("remove of %s failed", scratch);
02436 }
02437
02438 void
02439 test_nc_put_var_short(void)
02440 {
02441 int ncid;
02442 int varid;
02443 int i;
02444 int j;
02445 int err;
02446 int nels;
02447 size_t index[MAX_RANK];
02448 int canConvert;
02449 int allInExtRange;
02450 short value[MAX_NELS];
02451
02452 err = nc_create(scratch, NC_CLOBBER, &ncid);
02453 IF (err) {
02454 error("nc_create: %s", nc_strerror(err));
02455 return;
02456 }
02457 def_dims(ncid);
02458 def_vars(ncid);
02459 err = nc_enddef(ncid);
02460 IF (err)
02461 error("nc_enddef: %s", nc_strerror(err));
02462
02463 for (i = 0; i < NVARS; i++) {
02464 canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
02465 assert(var_rank[i] <= MAX_RANK);
02466 assert(var_nels[i] <= MAX_NELS);
02467 err = nc_put_var_short(BAD_ID, i, value);
02468 IF (err != NC_EBADID)
02469 error("bad ncid: status = %d", err);
02470 err = nc_put_var_short(ncid, BAD_VARID, value);
02471 IF (err != NC_ENOTVAR)
02472 error("bad var id: status = %d", err);
02473
02474 nels = 1;
02475 for (j = 0; j < var_rank[i]; j++) {
02476 nels *= var_shape[i][j];
02477 }
02478 for (allInExtRange = 1, j = 0; j < nels; j++) {
02479 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02480 IF (err)
02481 error("error in toMixedBase 1");
02482 value[j]= hash_short(var_type[i], var_rank[i], index, NCT_SHORT);
02483 allInExtRange = allInExtRange
02484 && inRange3(value[j], var_type[i], NCT_SHORT);
02485 }
02486 err = nc_put_var_short(ncid, i, value);
02487 if (canConvert) {
02488 if (allInExtRange) {
02489 IF (err)
02490 error("%s", nc_strerror(err));
02491 } else {
02492 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
02493 error("range error: status = %d", err);
02494 }
02495 } else {
02496 IF (nels > 0 && err != NC_ECHAR)
02497 error("wrong type: status = %d", err);
02498 }
02499 }
02500
02501
02502
02503
02504
02505
02506 err = nc_inq_varid(ncid, "cr", &varid);
02507 IF (err)
02508 error("nc_inq_varid: %s", nc_strerror(err));
02509 index[0] = NRECS-1;
02510 err = nc_put_var1_text(ncid, varid, index, "x");
02511 IF (err)
02512 error("nc_put_var1_text: %s", nc_strerror(err));
02513
02514 for (i = 0; i < NVARS; i++) {
02515 if (var_dimid[i][0] == RECDIM) {
02516 canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
02517 assert(var_rank[i] <= MAX_RANK);
02518 assert(var_nels[i] <= MAX_NELS);
02519 err = nc_put_var_short(BAD_ID, i, value);
02520
02521 nels = 1;
02522 for (j = 0; j < var_rank[i]; j++) {
02523 nels *= var_shape[i][j];
02524 }
02525 for (allInExtRange = 1, j = 0; j < nels; j++) {
02526 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02527 IF (err)
02528 error("error in toMixedBase 1");
02529 value[j]= hash_short(var_type[i], var_rank[i], index, NCT_SHORT);
02530 allInExtRange = allInExtRange
02531 && inRange3(value[j], var_type[i], NCT_SHORT);
02532 }
02533 err = nc_put_var_short(ncid, i, value);
02534 if (canConvert) {
02535 if (allInExtRange) {
02536 IF (err)
02537 error("%s", nc_strerror(err));
02538 } else {
02539 IF (err != NC_ERANGE)
02540 error("range error: status = %d", err);
02541 }
02542 } else {
02543 IF (nels > 0 && err != NC_ECHAR)
02544 error("wrong type: status = %d", err);
02545 }
02546 }
02547 }
02548
02549 err = nc_close(ncid);
02550 IF (err)
02551 error("nc_close: %s", nc_strerror(err));
02552
02553 check_vars_short(scratch);
02554
02555 err = remove(scratch);
02556 IF (err)
02557 error("remove of %s failed", scratch);
02558 }
02559
02560 void
02561 test_nc_put_var_int(void)
02562 {
02563 int ncid;
02564 int varid;
02565 int i;
02566 int j;
02567 int err;
02568 int nels;
02569 size_t index[MAX_RANK];
02570 int canConvert;
02571 int allInExtRange;
02572 int value[MAX_NELS];
02573
02574 err = nc_create(scratch, NC_CLOBBER, &ncid);
02575 IF (err) {
02576 error("nc_create: %s", nc_strerror(err));
02577 return;
02578 }
02579 def_dims(ncid);
02580 def_vars(ncid);
02581 err = nc_enddef(ncid);
02582 IF (err)
02583 error("nc_enddef: %s", nc_strerror(err));
02584
02585 for (i = 0; i < NVARS; i++) {
02586 canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
02587 assert(var_rank[i] <= MAX_RANK);
02588 assert(var_nels[i] <= MAX_NELS);
02589 err = nc_put_var_int(BAD_ID, i, value);
02590 IF (err != NC_EBADID)
02591 error("bad ncid: status = %d", err);
02592 err = nc_put_var_int(ncid, BAD_VARID, value);
02593 IF (err != NC_ENOTVAR)
02594 error("bad var id: status = %d", err);
02595
02596 nels = 1;
02597 for (j = 0; j < var_rank[i]; j++) {
02598 nels *= var_shape[i][j];
02599 }
02600 for (allInExtRange = 1, j = 0; j < nels; j++) {
02601 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02602 IF (err)
02603 error("error in toMixedBase 1");
02604 value[j]= hash_int(var_type[i], var_rank[i], index, NCT_INT);
02605 allInExtRange = allInExtRange
02606 && inRange3(value[j], var_type[i], NCT_INT);
02607 }
02608 err = nc_put_var_int(ncid, i, value);
02609 if (canConvert) {
02610 if (allInExtRange) {
02611 IF (err)
02612 error("%s", nc_strerror(err));
02613 } else {
02614 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
02615 error("range error: status = %d", err);
02616 }
02617 } else {
02618 IF (nels > 0 && err != NC_ECHAR)
02619 error("wrong type: status = %d", err);
02620 }
02621 }
02622
02623
02624
02625
02626
02627
02628 err = nc_inq_varid(ncid, "cr", &varid);
02629 IF (err)
02630 error("nc_inq_varid: %s", nc_strerror(err));
02631 index[0] = NRECS-1;
02632 err = nc_put_var1_text(ncid, varid, index, "x");
02633 IF (err)
02634 error("nc_put_var1_text: %s", nc_strerror(err));
02635
02636 for (i = 0; i < NVARS; i++) {
02637 if (var_dimid[i][0] == RECDIM) {
02638 canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
02639 assert(var_rank[i] <= MAX_RANK);
02640 assert(var_nels[i] <= MAX_NELS);
02641 err = nc_put_var_int(BAD_ID, i, value);
02642
02643 nels = 1;
02644 for (j = 0; j < var_rank[i]; j++) {
02645 nels *= var_shape[i][j];
02646 }
02647 for (allInExtRange = 1, j = 0; j < nels; j++) {
02648 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02649 IF (err)
02650 error("error in toMixedBase 1");
02651 value[j]= hash_int(var_type[i], var_rank[i], index, NCT_INT);
02652 allInExtRange = allInExtRange
02653 && inRange3(value[j], var_type[i], NCT_INT);
02654 }
02655 err = nc_put_var_int(ncid, i, value);
02656 if (canConvert) {
02657 if (allInExtRange) {
02658 IF (err)
02659 error("%s", nc_strerror(err));
02660 } else {
02661 IF (err != NC_ERANGE)
02662 error("range error: status = %d", err);
02663 }
02664 } else {
02665 IF (nels > 0 && err != NC_ECHAR)
02666 error("wrong type: status = %d", err);
02667 }
02668 }
02669 }
02670
02671 err = nc_close(ncid);
02672 IF (err)
02673 error("nc_close: %s", nc_strerror(err));
02674
02675 check_vars_int(scratch);
02676
02677 err = remove(scratch);
02678 IF (err)
02679 error("remove of %s failed", scratch);
02680 }
02681
02682 void
02683 test_nc_put_var_long(void)
02684 {
02685 int ncid;
02686 int varid;
02687 int i;
02688 int j;
02689 int err;
02690 int nels;
02691 size_t index[MAX_RANK];
02692 int canConvert;
02693 int allInExtRange;
02694 long value[MAX_NELS];
02695
02696 err = nc_create(scratch, NC_CLOBBER, &ncid);
02697 IF (err) {
02698 error("nc_create: %s", nc_strerror(err));
02699 return;
02700 }
02701 def_dims(ncid);
02702 def_vars(ncid);
02703 err = nc_enddef(ncid);
02704 IF (err)
02705 error("nc_enddef: %s", nc_strerror(err));
02706
02707 for (i = 0; i < NVARS; i++) {
02708 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
02709 assert(var_rank[i] <= MAX_RANK);
02710 assert(var_nels[i] <= MAX_NELS);
02711 err = nc_put_var_long(BAD_ID, i, value);
02712 IF (err != NC_EBADID)
02713 error("bad ncid: status = %d", err);
02714 err = nc_put_var_long(ncid, BAD_VARID, value);
02715 IF (err != NC_ENOTVAR)
02716 error("bad var id: status = %d", err);
02717
02718 nels = 1;
02719 for (j = 0; j < var_rank[i]; j++) {
02720 nels *= var_shape[i][j];
02721 }
02722 for (allInExtRange = 1, j = 0; j < nels; j++) {
02723 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02724 IF (err)
02725 error("error in toMixedBase 1");
02726 value[j]= hash_long(var_type[i], var_rank[i], index, NCT_LONG);
02727 allInExtRange = allInExtRange
02728 && inRange3(value[j], var_type[i], NCT_LONG);
02729 }
02730 err = nc_put_var_long(ncid, i, value);
02731 if (canConvert) {
02732 if (allInExtRange) {
02733 IF (err)
02734 error("%s", nc_strerror(err));
02735 } else {
02736 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
02737 error("range error: status = %d", err);
02738 }
02739 } else {
02740 IF (nels > 0 && err != NC_ECHAR)
02741 error("wrong type: status = %d", err);
02742 }
02743 }
02744
02745
02746
02747
02748
02749
02750 err = nc_inq_varid(ncid, "cr", &varid);
02751 IF (err)
02752 error("nc_inq_varid: %s", nc_strerror(err));
02753 index[0] = NRECS-1;
02754 err = nc_put_var1_text(ncid, varid, index, "x");
02755 IF (err)
02756 error("nc_put_var1_text: %s", nc_strerror(err));
02757
02758 for (i = 0; i < NVARS; i++) {
02759 if (var_dimid[i][0] == RECDIM) {
02760 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
02761 assert(var_rank[i] <= MAX_RANK);
02762 assert(var_nels[i] <= MAX_NELS);
02763 err = nc_put_var_long(BAD_ID, i, value);
02764
02765 nels = 1;
02766 for (j = 0; j < var_rank[i]; j++) {
02767 nels *= var_shape[i][j];
02768 }
02769 for (allInExtRange = 1, j = 0; j < nels; j++) {
02770 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02771 IF (err)
02772 error("error in toMixedBase 1");
02773 value[j]= hash_long(var_type[i], var_rank[i], index, NCT_LONG);
02774 allInExtRange = allInExtRange
02775 && inRange3(value[j], var_type[i], NCT_LONG);
02776 }
02777 err = nc_put_var_long(ncid, i, value);
02778 if (canConvert) {
02779 if (allInExtRange) {
02780 IF (err)
02781 error("%s", nc_strerror(err));
02782 } else {
02783 IF (err != NC_ERANGE)
02784 error("range error: status = %d", err);
02785 }
02786 } else {
02787 IF (nels > 0 && err != NC_ECHAR)
02788 error("wrong type: status = %d", err);
02789 }
02790 }
02791 }
02792
02793 err = nc_close(ncid);
02794 IF (err)
02795 error("nc_close: %s", nc_strerror(err));
02796
02797 check_vars_long(scratch);
02798
02799 err = remove(scratch);
02800 IF (err)
02801 error("remove of %s failed", scratch);
02802 }
02803
02804 void
02805 test_nc_put_var_float(void)
02806 {
02807 int ncid;
02808 int varid;
02809 int i;
02810 int j;
02811 int err;
02812 int nels;
02813 size_t index[MAX_RANK];
02814 int canConvert;
02815 int allInExtRange;
02816 float value[MAX_NELS];
02817
02818 err = nc_create(scratch, NC_CLOBBER, &ncid);
02819 IF (err) {
02820 error("nc_create: %s", nc_strerror(err));
02821 return;
02822 }
02823 def_dims(ncid);
02824 def_vars(ncid);
02825 err = nc_enddef(ncid);
02826 IF (err)
02827 error("nc_enddef: %s", nc_strerror(err));
02828
02829 for (i = 0; i < NVARS; i++) {
02830 canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
02831 assert(var_rank[i] <= MAX_RANK);
02832 assert(var_nels[i] <= MAX_NELS);
02833 err = nc_put_var_float(BAD_ID, i, value);
02834 IF (err != NC_EBADID)
02835 error("bad ncid: status = %d", err);
02836 err = nc_put_var_float(ncid, BAD_VARID, value);
02837 IF (err != NC_ENOTVAR)
02838 error("bad var id: status = %d", err);
02839
02840 nels = 1;
02841 for (j = 0; j < var_rank[i]; j++) {
02842 nels *= var_shape[i][j];
02843 }
02844 for (allInExtRange = 1, j = 0; j < nels; j++) {
02845 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02846 IF (err)
02847 error("error in toMixedBase 1");
02848 value[j]= hash_float(var_type[i], var_rank[i], index, NCT_FLOAT);
02849 allInExtRange = allInExtRange
02850 && inRange3(value[j], var_type[i], NCT_FLOAT);
02851 }
02852 err = nc_put_var_float(ncid, i, value);
02853 if (canConvert) {
02854 if (allInExtRange) {
02855 IF (err)
02856 error("%s", nc_strerror(err));
02857 } else {
02858 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
02859 error("range error: status = %d", err);
02860 }
02861 } else {
02862 IF (nels > 0 && err != NC_ECHAR)
02863 error("wrong type: status = %d", err);
02864 }
02865 }
02866
02867
02868
02869
02870
02871
02872 err = nc_inq_varid(ncid, "cr", &varid);
02873 IF (err)
02874 error("nc_inq_varid: %s", nc_strerror(err));
02875 index[0] = NRECS-1;
02876 err = nc_put_var1_text(ncid, varid, index, "x");
02877 IF (err)
02878 error("nc_put_var1_text: %s", nc_strerror(err));
02879
02880 for (i = 0; i < NVARS; i++) {
02881 if (var_dimid[i][0] == RECDIM) {
02882 canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
02883 assert(var_rank[i] <= MAX_RANK);
02884 assert(var_nels[i] <= MAX_NELS);
02885 err = nc_put_var_float(BAD_ID, i, value);
02886
02887 nels = 1;
02888 for (j = 0; j < var_rank[i]; j++) {
02889 nels *= var_shape[i][j];
02890 }
02891 for (allInExtRange = 1, j = 0; j < nels; j++) {
02892 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02893 IF (err)
02894 error("error in toMixedBase 1");
02895 value[j]= hash_float(var_type[i], var_rank[i], index, NCT_FLOAT);
02896 allInExtRange = allInExtRange
02897 && inRange3(value[j], var_type[i], NCT_FLOAT);
02898 }
02899 err = nc_put_var_float(ncid, i, value);
02900 if (canConvert) {
02901 if (allInExtRange) {
02902 IF (err)
02903 error("%s", nc_strerror(err));
02904 } else {
02905 IF (err != NC_ERANGE)
02906 error("range error: status = %d", err);
02907 }
02908 } else {
02909 IF (nels > 0 && err != NC_ECHAR)
02910 error("wrong type: status = %d", err);
02911 }
02912 }
02913 }
02914
02915 err = nc_close(ncid);
02916 IF (err)
02917 error("nc_close: %s", nc_strerror(err));
02918
02919 check_vars_float(scratch);
02920
02921 err = remove(scratch);
02922 IF (err)
02923 error("remove of %s failed", scratch);
02924 }
02925
02926 void
02927 test_nc_put_var_double(void)
02928 {
02929 int ncid;
02930 int varid;
02931 int i;
02932 int j;
02933 int err;
02934 int nels;
02935 size_t index[MAX_RANK];
02936 int canConvert;
02937 int allInExtRange;
02938 double value[MAX_NELS];
02939
02940 err = nc_create(scratch, NC_CLOBBER, &ncid);
02941 IF (err) {
02942 error("nc_create: %s", nc_strerror(err));
02943 return;
02944 }
02945 def_dims(ncid);
02946 def_vars(ncid);
02947 err = nc_enddef(ncid);
02948 IF (err)
02949 error("nc_enddef: %s", nc_strerror(err));
02950
02951 for (i = 0; i < NVARS; i++) {
02952 canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
02953 assert(var_rank[i] <= MAX_RANK);
02954 assert(var_nels[i] <= MAX_NELS);
02955 err = nc_put_var_double(BAD_ID, i, value);
02956 IF (err != NC_EBADID)
02957 error("bad ncid: status = %d", err);
02958 err = nc_put_var_double(ncid, BAD_VARID, value);
02959 IF (err != NC_ENOTVAR)
02960 error("bad var id: status = %d", err);
02961
02962 nels = 1;
02963 for (j = 0; j < var_rank[i]; j++) {
02964 nels *= var_shape[i][j];
02965 }
02966 for (allInExtRange = 1, j = 0; j < nels; j++) {
02967 err = toMixedBase(j, var_rank[i], var_shape[i], index);
02968 IF (err)
02969 error("error in toMixedBase 1");
02970 value[j]= hash_double(var_type[i], var_rank[i], index, NCT_DOUBLE);
02971 allInExtRange = allInExtRange
02972 && inRange3(value[j], var_type[i], NCT_DOUBLE);
02973 }
02974 err = nc_put_var_double(ncid, i, value);
02975 if (canConvert) {
02976 if (allInExtRange) {
02977 IF (err)
02978 error("%s", nc_strerror(err));
02979 } else {
02980 IF (err != NC_ERANGE && var_dimid[i][0] != RECDIM)
02981 error("range error: status = %d", err);
02982 }
02983 } else {
02984 IF (nels > 0 && err != NC_ECHAR)
02985 error("wrong type: status = %d", err);
02986 }
02987 }
02988
02989
02990
02991
02992
02993
02994 err = nc_inq_varid(ncid, "cr", &varid);
02995 IF (err)
02996 error("nc_inq_varid: %s", nc_strerror(err));
02997 index[0] = NRECS-1;
02998 err = nc_put_var1_text(ncid, varid, index, "x");
02999 IF (err)
03000 error("nc_put_var1_text: %s", nc_strerror(err));
03001
03002 for (i = 0; i < NVARS; i++) {
03003 if (var_dimid[i][0] == RECDIM) {
03004 canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
03005 assert(var_rank[i] <= MAX_RANK);
03006 assert(var_nels[i] <= MAX_NELS);
03007 err = nc_put_var_double(BAD_ID, i, value);
03008
03009 nels = 1;
03010 for (j = 0; j < var_rank[i]; j++) {
03011 nels *= var_shape[i][j];
03012 }
03013 for (allInExtRange = 1, j = 0; j < nels; j++) {
03014 err = toMixedBase(j, var_rank[i], var_shape[i], index);
03015 IF (err)
03016 error("error in toMixedBase 1");
03017 value[j]= hash_double(var_type[i], var_rank[i], index, NCT_DOUBLE);
03018 allInExtRange = allInExtRange
03019 && inRange3(value[j], var_type[i], NCT_DOUBLE);
03020 }
03021 err = nc_put_var_double(ncid, i, value);
03022 if (canConvert) {
03023 if (allInExtRange) {
03024 IF (err)
03025 error("%s", nc_strerror(err));
03026 } else {
03027 IF (err != NC_ERANGE)
03028 error("range error: status = %d", err);
03029 }
03030 } else {
03031 IF (nels > 0 && err != NC_ECHAR)
03032 error("wrong type: status = %d", err);
03033 }
03034 }
03035 }
03036
03037 err = nc_close(ncid);
03038 IF (err)
03039 error("nc_close: %s", nc_strerror(err));
03040
03041 check_vars_double(scratch);
03042
03043 err = remove(scratch);
03044 IF (err)
03045 error("remove of %s failed", scratch);
03046 }
03047
03048
03049
03050
03051 void
03052 test_nc_put_vara_text(void)
03053 {
03054 int ncid;
03055 int d;
03056 int i;
03057 int j;
03058 int k;
03059 int err;
03060 int nslabs;
03061 int nels;
03062 size_t start[MAX_RANK];
03063 size_t edge[MAX_RANK];
03064 size_t mid[MAX_RANK];
03065 size_t index[MAX_RANK];
03066 int canConvert;
03067 int allInExtRange;
03068 text value[MAX_NELS];
03069
03070 err = nc_create(scratch, NC_CLOBBER, &ncid);
03071 IF (err) {
03072 error("nc_create: %s", nc_strerror(err));
03073 return;
03074 }
03075 def_dims(ncid);
03076 def_vars(ncid);
03077 err = nc_enddef(ncid);
03078 IF (err)
03079 error("nc_enddef: %s", nc_strerror(err));
03080
03081 value[0] = 0;
03082 for (i = 0; i < NVARS; i++) {
03083 canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
03084 assert(var_rank[i] <= MAX_RANK);
03085 assert(var_nels[i] <= MAX_NELS);
03086 for (j = 0; j < var_rank[i]; j++) {
03087 start[j] = 0;
03088 edge[j] = 1;
03089 }
03090 err = nc_put_vara_text(BAD_ID, i, start, edge, value);
03091 IF (err != NC_EBADID)
03092 error("bad ncid: status = %d", err);
03093 err = nc_put_vara_text(ncid, BAD_VARID, start, edge, value);
03094 IF (err != NC_ENOTVAR)
03095 error("bad var id: status = %d", err);
03096 for (j = 0; j < var_rank[i]; j++) {
03097 if (var_dimid[i][j] > 0) {
03098 start[j] = var_shape[i][j];
03099 err = nc_put_vara_text(ncid, i, start, edge, value);
03100 IF (canConvert && err != NC_EINVALCOORDS)
03101 error("bad start: status = %d", err);
03102 start[j] = 0;
03103 edge[j] = var_shape[i][j] + 1;
03104 err = nc_put_vara_text(ncid, i, start, edge, value);
03105 IF (canConvert && err != NC_EEDGE)
03106 error("bad edge: status = %d", err);
03107 edge[j] = 1;
03108 }
03109 }
03110
03111 for (j = 0; j < var_rank[i]; j++) {
03112 edge[j] = 0;
03113 }
03114 err = nc_put_vara_text(BAD_ID, i, start, edge, value);
03115 IF (err != NC_EBADID)
03116 error("bad ncid: status = %d", err);
03117 err = nc_put_vara_text(ncid, BAD_VARID, start, edge, value);
03118 IF (err != NC_ENOTVAR)
03119 error("bad var id: status = %d", err);
03120 for (j = 0; j < var_rank[i]; j++) {
03121 if (var_dimid[i][j] > 0) {
03122 start[j] = var_shape[i][j];
03123 err = nc_put_vara_text(ncid, i, start, edge, value);
03124 IF (canConvert && err != NC_EINVALCOORDS)
03125 error("bad start: status = %d", err);
03126 start[j] = 0;
03127 }
03128 }
03129 err = nc_put_vara_text(ncid, i, start, edge, value);
03130 if (canConvert) {
03131 IF (err)
03132 error("%s", nc_strerror(err));
03133 } else {
03134 IF (err != NC_ECHAR)
03135 error("wrong type: status = %d", err);
03136 }
03137 for (j = 0; j < var_rank[i]; j++) {
03138 edge[j] = 1;
03139 }
03140
03141
03142
03143 nslabs = 1;
03144 for (j = 0; j < var_rank[i]; j++) {
03145 mid[j] = roll( var_shape[i][j] );
03146 nslabs *= 2;
03147 }
03148
03149 for (k = 0; k < nslabs; k++) {
03150 nels = 1;
03151 for (j = 0; j < var_rank[i]; j++) {
03152 if ((k >> j) & 1) {
03153 start[j] = 0;
03154 edge[j] = mid[j];
03155 }else{
03156 start[j] = mid[j];
03157 edge[j] = var_shape[i][j] - mid[j];
03158 }
03159 nels *= edge[j];
03160 }
03161 for (allInExtRange = 1, j = 0; j < nels; j++) {
03162 err = toMixedBase(j, var_rank[i], edge, index);
03163 IF (err)
03164 error("error in toMixedBase 1");
03165 for (d = 0; d < var_rank[i]; d++)
03166 index[d] += start[d];
03167 value[j]= hash_text(var_type[i], var_rank[i], index, NCT_TEXT);
03168 allInExtRange = allInExtRange
03169 && inRange3(value[j], var_type[i], NCT_TEXT);
03170 }
03171 if (var_rank[i] == 0 && i%2 == 0)
03172 err = nc_put_vara_text(ncid, i, NULL, NULL, value);
03173 else
03174 err = nc_put_vara_text(ncid, i, start, edge, value);
03175 if (canConvert) {
03176 if (allInExtRange) {
03177 IF (err)
03178 error("%s", nc_strerror(err));
03179 } else {
03180 IF (err != NC_ERANGE)
03181 error("range error: status = %d", err);
03182 }
03183 } else {
03184 IF (nels > 0 && err != NC_ECHAR)
03185 error("wrong type: status = %d", err);
03186 }
03187 }
03188 }
03189
03190 err = nc_close(ncid);
03191 IF (err)
03192 error("nc_close: %s", nc_strerror(err));
03193
03194 check_vars_text(scratch);
03195
03196 err = remove(scratch);
03197 IF (err)
03198 error("remove of %s failed", scratch);
03199 }
03200
03201 void
03202 test_nc_put_vara_uchar(void)
03203 {
03204 int ncid;
03205 int d;
03206 int i;
03207 int j;
03208 int k;
03209 int err;
03210 int nslabs;
03211 int nels;
03212 size_t start[MAX_RANK];
03213 size_t edge[MAX_RANK];
03214 size_t mid[MAX_RANK];
03215 size_t index[MAX_RANK];
03216 int canConvert;
03217 int allInExtRange;
03218 uchar value[MAX_NELS];
03219
03220 err = nc_create(scratch, NC_CLOBBER, &ncid);
03221 IF (err) {
03222 error("nc_create: %s", nc_strerror(err));
03223 return;
03224 }
03225 def_dims(ncid);
03226 def_vars(ncid);
03227 err = nc_enddef(ncid);
03228 IF (err)
03229 error("nc_enddef: %s", nc_strerror(err));
03230
03231 value[0] = 0;
03232 for (i = 0; i < NVARS; i++) {
03233 canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
03234 assert(var_rank[i] <= MAX_RANK);
03235 assert(var_nels[i] <= MAX_NELS);
03236 for (j = 0; j < var_rank[i]; j++) {
03237 start[j] = 0;
03238 edge[j] = 1;
03239 }
03240 err = nc_put_vara_uchar(BAD_ID, i, start, edge, value);
03241 IF (err != NC_EBADID)
03242 error("bad ncid: status = %d", err);
03243 err = nc_put_vara_uchar(ncid, BAD_VARID, start, edge, value);
03244 IF (err != NC_ENOTVAR)
03245 error("bad var id: status = %d", err);
03246 for (j = 0; j < var_rank[i]; j++) {
03247 if (var_dimid[i][j] > 0) {
03248 start[j] = var_shape[i][j];
03249 err = nc_put_vara_uchar(ncid, i, start, edge, value);
03250 IF (canConvert && err != NC_EINVALCOORDS)
03251 error("bad start: status = %d", err);
03252 start[j] = 0;
03253 edge[j] = var_shape[i][j] + 1;
03254 err = nc_put_vara_uchar(ncid, i, start, edge, value);
03255 IF (canConvert && err != NC_EEDGE)
03256 error("bad edge: status = %d", err);
03257 edge[j] = 1;
03258 }
03259 }
03260
03261 for (j = 0; j < var_rank[i]; j++) {
03262 edge[j] = 0;
03263 }
03264 err = nc_put_vara_uchar(BAD_ID, i, start, edge, value);
03265 IF (err != NC_EBADID)
03266 error("bad ncid: status = %d", err);
03267 err = nc_put_vara_uchar(ncid, BAD_VARID, start, edge, value);
03268 IF (err != NC_ENOTVAR)
03269 error("bad var id: status = %d", err);
03270 for (j = 0; j < var_rank[i]; j++) {
03271 if (var_dimid[i][j] > 0) {
03272 start[j] = var_shape[i][j];
03273 err = nc_put_vara_uchar(ncid, i, start, edge, value);
03274 IF (canConvert && err != NC_EINVALCOORDS)
03275 error("bad start: status = %d", err);
03276 start[j] = 0;
03277 }
03278 }
03279 err = nc_put_vara_uchar(ncid, i, start, edge, value);
03280 if (canConvert) {
03281 IF (err)
03282 error("%s", nc_strerror(err));
03283 } else {
03284 IF (err != NC_ECHAR)
03285 error("wrong type: status = %d", err);
03286 }
03287 for (j = 0; j < var_rank[i]; j++) {
03288 edge[j] = 1;
03289 }
03290
03291
03292
03293 nslabs = 1;
03294 for (j = 0; j < var_rank[i]; j++) {
03295 mid[j] = roll( var_shape[i][j] );
03296 nslabs *= 2;
03297 }
03298
03299 for (k = 0; k < nslabs; k++) {
03300 nels = 1;
03301 for (j = 0; j < var_rank[i]; j++) {
03302 if ((k >> j) & 1) {
03303 start[j] = 0;
03304 edge[j] = mid[j];
03305 }else{
03306 start[j] = mid[j];
03307 edge[j] = var_shape[i][j] - mid[j];
03308 }
03309 nels *= edge[j];
03310 }
03311 for (allInExtRange = 1, j = 0; j < nels; j++) {
03312 err = toMixedBase(j, var_rank[i], edge, index);
03313 IF (err)
03314 error("error in toMixedBase 1");
03315 for (d = 0; d < var_rank[i]; d++)
03316 index[d] += start[d];
03317 value[j]= hash_uchar(var_type[i], var_rank[i], index, NCT_UCHAR);
03318 allInExtRange = allInExtRange
03319 && inRange3(value[j], var_type[i], NCT_UCHAR);
03320 }
03321 if (var_rank[i] == 0 && i%2 == 0)
03322 err = nc_put_vara_uchar(ncid, i, NULL, NULL, value);
03323 else
03324 err = nc_put_vara_uchar(ncid, i, start, edge, value);
03325 if (canConvert) {
03326 if (allInExtRange) {
03327 IF (err)
03328 error("%s", nc_strerror(err));
03329 } else {
03330 IF (err != NC_ERANGE)
03331 error("range error: status = %d", err);
03332 }
03333 } else {
03334 IF (nels > 0 && err != NC_ECHAR)
03335 error("wrong type: status = %d", err);
03336 }
03337 }
03338 }
03339
03340 err = nc_close(ncid);
03341 IF (err)
03342 error("nc_close: %s", nc_strerror(err));
03343
03344 check_vars_uchar(scratch);
03345
03346 err = remove(scratch);
03347 IF (err)
03348 error("remove of %s failed", scratch);
03349 }
03350
03351 void
03352 test_nc_put_vara_schar(void)
03353 {
03354 int ncid;
03355 int d;
03356 int i;
03357 int j;
03358 int k;
03359 int err;
03360 int nslabs;
03361 int nels;
03362 size_t start[MAX_RANK];
03363 size_t edge[MAX_RANK];
03364 size_t mid[MAX_RANK];
03365 size_t index[MAX_RANK];
03366 int canConvert;
03367 int allInExtRange;
03368 schar value[MAX_NELS];
03369
03370 err = nc_create(scratch, NC_CLOBBER, &ncid);
03371 IF (err) {
03372 error("nc_create: %s", nc_strerror(err));
03373 return;
03374 }
03375 def_dims(ncid);
03376 def_vars(ncid);
03377 err = nc_enddef(ncid);
03378 IF (err)
03379 error("nc_enddef: %s", nc_strerror(err));
03380
03381 value[0] = 0;
03382 for (i = 0; i < NVARS; i++) {
03383 canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
03384 assert(var_rank[i] <= MAX_RANK);
03385 assert(var_nels[i] <= MAX_NELS);
03386 for (j = 0; j < var_rank[i]; j++) {
03387 start[j] = 0;
03388 edge[j] = 1;
03389 }
03390 err = nc_put_vara_schar(BAD_ID, i, start, edge, value);
03391 IF (err != NC_EBADID)
03392 error("bad ncid: status = %d", err);
03393 err = nc_put_vara_schar(ncid, BAD_VARID, start, edge, value);
03394 IF (err != NC_ENOTVAR)
03395 error("bad var id: status = %d", err);
03396 for (j = 0; j < var_rank[i]; j++) {
03397 if (var_dimid[i][j] > 0) {
03398 start[j] = var_shape[i][j];
03399 err = nc_put_vara_schar(ncid, i, start, edge, value);
03400 IF (canConvert && err != NC_EINVALCOORDS)
03401 error("bad start: status = %d", err);
03402 start[j] = 0;
03403 edge[j] = var_shape[i][j] + 1;
03404 err = nc_put_vara_schar(ncid, i, start, edge, value);
03405 IF (canConvert && err != NC_EEDGE)
03406 error("bad edge: status = %d", err);
03407 edge[j] = 1;
03408 }
03409 }
03410
03411 for (j = 0; j < var_rank[i]; j++) {
03412 edge[j] = 0;
03413 }
03414 err = nc_put_vara_schar(BAD_ID, i, start, edge, value);
03415 IF (err != NC_EBADID)
03416 error("bad ncid: status = %d", err);
03417 err = nc_put_vara_schar(ncid, BAD_VARID, start, edge, value);
03418 IF (err != NC_ENOTVAR)
03419 error("bad var id: status = %d", err);
03420 for (j = 0; j < var_rank[i]; j++) {
03421 if (var_dimid[i][j] > 0) {
03422 start[j] = var_shape[i][j];
03423 err = nc_put_vara_schar(ncid, i, start, edge, value);
03424 IF (canConvert && err != NC_EINVALCOORDS)
03425 error("bad start: status = %d", err);
03426 start[j] = 0;
03427 }
03428 }
03429 err = nc_put_vara_schar(ncid, i, start, edge, value);
03430 if (canConvert) {
03431 IF (err)
03432 error("%s", nc_strerror(err));
03433 } else {
03434 IF (err != NC_ECHAR)
03435 error("wrong type: status = %d", err);
03436 }
03437 for (j = 0; j < var_rank[i]; j++) {
03438 edge[j] = 1;
03439 }
03440
03441
03442
03443 nslabs = 1;
03444 for (j = 0; j < var_rank[i]; j++) {
03445 mid[j] = roll( var_shape[i][j] );
03446 nslabs *= 2;
03447 }
03448
03449 for (k = 0; k < nslabs; k++) {
03450 nels = 1;
03451 for (j = 0; j < var_rank[i]; j++) {
03452 if ((k >> j) & 1) {
03453 start[j] = 0;
03454 edge[j] = mid[j];
03455 }else{
03456 start[j] = mid[j];
03457 edge[j] = var_shape[i][j] - mid[j];
03458 }
03459 nels *= edge[j];
03460 }
03461 for (allInExtRange = 1, j = 0; j < nels; j++) {
03462 err = toMixedBase(j, var_rank[i], edge, index);
03463 IF (err)
03464 error("error in toMixedBase 1");
03465 for (d = 0; d < var_rank[i]; d++)
03466 index[d] += start[d];
03467 value[j]= hash_schar(var_type[i], var_rank[i], index, NCT_SCHAR);
03468 allInExtRange = allInExtRange
03469 && inRange3(value[j], var_type[i], NCT_SCHAR);
03470 }
03471 if (var_rank[i] == 0 && i%2 == 0)
03472 err = nc_put_vara_schar(ncid, i, NULL, NULL, value);
03473 else
03474 err = nc_put_vara_schar(ncid, i, start, edge, value);
03475 if (canConvert) {
03476 if (allInExtRange) {
03477 IF (err)
03478 error("%s", nc_strerror(err));
03479 } else {
03480 IF (err != NC_ERANGE)
03481 error("range error: status = %d", err);
03482 }
03483 } else {
03484 IF (nels > 0 && err != NC_ECHAR)
03485 error("wrong type: status = %d", err);
03486 }
03487 }
03488 }
03489
03490 err = nc_close(ncid);
03491 IF (err)
03492 error("nc_close: %s", nc_strerror(err));
03493
03494 check_vars_schar(scratch);
03495
03496 err = remove(scratch);
03497 IF (err)
03498 error("remove of %s failed", scratch);
03499 }
03500
03501 void
03502 test_nc_put_vara_short(void)
03503 {
03504 int ncid;
03505 int d;
03506 int i;
03507 int j;
03508 int k;
03509 int err;
03510 int nslabs;
03511 int nels;
03512 size_t start[MAX_RANK];
03513 size_t edge[MAX_RANK];
03514 size_t mid[MAX_RANK];
03515 size_t index[MAX_RANK];
03516 int canConvert;
03517 int allInExtRange;
03518 short value[MAX_NELS];
03519
03520 err = nc_create(scratch, NC_CLOBBER, &ncid);
03521 IF (err) {
03522 error("nc_create: %s", nc_strerror(err));
03523 return;
03524 }
03525 def_dims(ncid);
03526 def_vars(ncid);
03527 err = nc_enddef(ncid);
03528 IF (err)
03529 error("nc_enddef: %s", nc_strerror(err));
03530
03531 value[0] = 0;
03532 for (i = 0; i < NVARS; i++) {
03533 canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
03534 assert(var_rank[i] <= MAX_RANK);
03535 assert(var_nels[i] <= MAX_NELS);
03536 for (j = 0; j < var_rank[i]; j++) {
03537 start[j] = 0;
03538 edge[j] = 1;
03539 }
03540 err = nc_put_vara_short(BAD_ID, i, start, edge, value);
03541 IF (err != NC_EBADID)
03542 error("bad ncid: status = %d", err);
03543 err = nc_put_vara_short(ncid, BAD_VARID, start, edge, value);
03544 IF (err != NC_ENOTVAR)
03545 error("bad var id: status = %d", err);
03546 for (j = 0; j < var_rank[i]; j++) {
03547 if (var_dimid[i][j] > 0) {
03548 start[j] = var_shape[i][j];
03549 err = nc_put_vara_short(ncid, i, start, edge, value);
03550 IF (canConvert && err != NC_EINVALCOORDS)
03551 error("bad start: status = %d", err);
03552 start[j] = 0;
03553 edge[j] = var_shape[i][j] + 1;
03554 err = nc_put_vara_short(ncid, i, start, edge, value);
03555 IF (canConvert && err != NC_EEDGE)
03556 error("bad edge: status = %d", err);
03557 edge[j] = 1;
03558 }
03559 }
03560
03561 for (j = 0; j < var_rank[i]; j++) {
03562 edge[j] = 0;
03563 }
03564 err = nc_put_vara_short(BAD_ID, i, start, edge, value);
03565 IF (err != NC_EBADID)
03566 error("bad ncid: status = %d", err);
03567 err = nc_put_vara_short(ncid, BAD_VARID, start, edge, value);
03568 IF (err != NC_ENOTVAR)
03569 error("bad var id: status = %d", err);
03570 for (j = 0; j < var_rank[i]; j++) {
03571 if (var_dimid[i][j] > 0) {
03572 start[j] = var_shape[i][j];
03573 err = nc_put_vara_short(ncid, i, start, edge, value);
03574 IF (canConvert && err != NC_EINVALCOORDS)
03575 error("bad start: status = %d", err);
03576 start[j] = 0;
03577 }
03578 }
03579 err = nc_put_vara_short(ncid, i, start, edge, value);
03580 if (canConvert) {
03581 IF (err)
03582 error("%s", nc_strerror(err));
03583 } else {
03584 IF (err != NC_ECHAR)
03585 error("wrong type: status = %d", err);
03586 }
03587 for (j = 0; j < var_rank[i]; j++) {
03588 edge[j] = 1;
03589 }
03590
03591
03592
03593 nslabs = 1;
03594 for (j = 0; j < var_rank[i]; j++) {
03595 mid[j] = roll( var_shape[i][j] );
03596 nslabs *= 2;
03597 }
03598
03599 for (k = 0; k < nslabs; k++) {
03600 nels = 1;
03601 for (j = 0; j < var_rank[i]; j++) {
03602 if ((k >> j) & 1) {
03603 start[j] = 0;
03604 edge[j] = mid[j];
03605 }else{
03606 start[j] = mid[j];
03607 edge[j] = var_shape[i][j] - mid[j];
03608 }
03609 nels *= edge[j];
03610 }
03611 for (allInExtRange = 1, j = 0; j < nels; j++) {
03612 err = toMixedBase(j, var_rank[i], edge, index);
03613 IF (err)
03614 error("error in toMixedBase 1");
03615 for (d = 0; d < var_rank[i]; d++)
03616 index[d] += start[d];
03617 value[j]= hash_short(var_type[i], var_rank[i], index, NCT_SHORT);
03618 allInExtRange = allInExtRange
03619 && inRange3(value[j], var_type[i], NCT_SHORT);
03620 }
03621 if (var_rank[i] == 0 && i%2 == 0)
03622 err = nc_put_vara_short(ncid, i, NULL, NULL, value);
03623 else
03624 err = nc_put_vara_short(ncid, i, start, edge, value);
03625 if (canConvert) {
03626 if (allInExtRange) {
03627 IF (err)
03628 error("%s", nc_strerror(err));
03629 } else {
03630 IF (err != NC_ERANGE)
03631 error("range error: status = %d", err);
03632 }
03633 } else {
03634 IF (nels > 0 && err != NC_ECHAR)
03635 error("wrong type: status = %d", err);
03636 }
03637 }
03638 }
03639
03640 err = nc_close(ncid);
03641 IF (err)
03642 error("nc_close: %s", nc_strerror(err));
03643
03644 check_vars_short(scratch);
03645
03646 err = remove(scratch);
03647 IF (err)
03648 error("remove of %s failed", scratch);
03649 }
03650
03651 void
03652 test_nc_put_vara_int(void)
03653 {
03654 int ncid;
03655 int d;
03656 int i;
03657 int j;
03658 int k;
03659 int err;
03660 int nslabs;
03661 int nels;
03662 size_t start[MAX_RANK];
03663 size_t edge[MAX_RANK];
03664 size_t mid[MAX_RANK];
03665 size_t index[MAX_RANK];
03666 int canConvert;
03667 int allInExtRange;
03668 int value[MAX_NELS];
03669
03670 err = nc_create(scratch, NC_CLOBBER, &ncid);
03671 IF (err) {
03672 error("nc_create: %s", nc_strerror(err));
03673 return;
03674 }
03675 def_dims(ncid);
03676 def_vars(ncid);
03677 err = nc_enddef(ncid);
03678 IF (err)
03679 error("nc_enddef: %s", nc_strerror(err));
03680
03681 value[0] = 0;
03682 for (i = 0; i < NVARS; i++) {
03683 canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
03684 assert(var_rank[i] <= MAX_RANK);
03685 assert(var_nels[i] <= MAX_NELS);
03686 for (j = 0; j < var_rank[i]; j++) {
03687 start[j] = 0;
03688 edge[j] = 1;
03689 }
03690 err = nc_put_vara_int(BAD_ID, i, start, edge, value);
03691 IF (err != NC_EBADID)
03692 error("bad ncid: status = %d", err);
03693 err = nc_put_vara_int(ncid, BAD_VARID, start, edge, value);
03694 IF (err != NC_ENOTVAR)
03695 error("bad var id: status = %d", err);
03696 for (j = 0; j < var_rank[i]; j++) {
03697 if (var_dimid[i][j] > 0) {
03698 start[j] = var_shape[i][j];
03699 err = nc_put_vara_int(ncid, i, start, edge, value);
03700 IF (canConvert && err != NC_EINVALCOORDS)
03701 error("bad start: status = %d", err);
03702 start[j] = 0;
03703 edge[j] = var_shape[i][j] + 1;
03704 err = nc_put_vara_int(ncid, i, start, edge, value);
03705 IF (canConvert && err != NC_EEDGE)
03706 error("bad edge: status = %d", err);
03707 edge[j] = 1;
03708 }
03709 }
03710
03711 for (j = 0; j < var_rank[i]; j++) {
03712 edge[j] = 0;
03713 }
03714 err = nc_put_vara_int(BAD_ID, i, start, edge, value);
03715 IF (err != NC_EBADID)
03716 error("bad ncid: status = %d", err);
03717 err = nc_put_vara_int(ncid, BAD_VARID, start, edge, value);
03718 IF (err != NC_ENOTVAR)
03719 error("bad var id: status = %d", err);
03720 for (j = 0; j < var_rank[i]; j++) {
03721 if (var_dimid[i][j] > 0) {
03722 start[j] = var_shape[i][j];
03723 err = nc_put_vara_int(ncid, i, start, edge, value);
03724 IF (canConvert && err != NC_EINVALCOORDS)
03725 error("bad start: status = %d", err);
03726 start[j] = 0;
03727 }
03728 }
03729 err = nc_put_vara_int(ncid, i, start, edge, value);
03730 if (canConvert) {
03731 IF (err)
03732 error("%s", nc_strerror(err));
03733 } else {
03734 IF (err != NC_ECHAR)
03735 error("wrong type: status = %d", err);
03736 }
03737 for (j = 0; j < var_rank[i]; j++) {
03738 edge[j] = 1;
03739 }
03740
03741
03742
03743 nslabs = 1;
03744 for (j = 0; j < var_rank[i]; j++) {
03745 mid[j] = roll( var_shape[i][j] );
03746 nslabs *= 2;
03747 }
03748
03749 for (k = 0; k < nslabs; k++) {
03750 nels = 1;
03751 for (j = 0; j < var_rank[i]; j++) {
03752 if ((k >> j) & 1) {
03753 start[j] = 0;
03754 edge[j] = mid[j];
03755 }else{
03756 start[j] = mid[j];
03757 edge[j] = var_shape[i][j] - mid[j];
03758 }
03759 nels *= edge[j];
03760 }
03761 for (allInExtRange = 1, j = 0; j < nels; j++) {
03762 err = toMixedBase(j, var_rank[i], edge, index);
03763 IF (err)
03764 error("error in toMixedBase 1");
03765 for (d = 0; d < var_rank[i]; d++)
03766 index[d] += start[d];
03767 value[j]= hash_int(var_type[i], var_rank[i], index, NCT_INT);
03768 allInExtRange = allInExtRange
03769 && inRange3(value[j], var_type[i], NCT_INT);
03770 }
03771 if (var_rank[i] == 0 && i%2 == 0)
03772 err = nc_put_vara_int(ncid, i, NULL, NULL, value);
03773 else
03774 err = nc_put_vara_int(ncid, i, start, edge, value);
03775 if (canConvert) {
03776 if (allInExtRange) {
03777 IF (err)
03778 error("%s", nc_strerror(err));
03779 } else {
03780 IF (err != NC_ERANGE)
03781 error("range error: status = %d", err);
03782 }
03783 } else {
03784 IF (nels > 0 && err != NC_ECHAR)
03785 error("wrong type: status = %d", err);
03786 }
03787 }
03788 }
03789
03790 err = nc_close(ncid);
03791 IF (err)
03792 error("nc_close: %s", nc_strerror(err));
03793
03794 check_vars_int(scratch);
03795
03796 err = remove(scratch);
03797 IF (err)
03798 error("remove of %s failed", scratch);
03799 }
03800
03801 void
03802 test_nc_put_vara_long(void)
03803 {
03804 int ncid;
03805 int d;
03806 int i;
03807 int j;
03808 int k;
03809 int err;
03810 int nslabs;
03811 int nels;
03812 size_t start[MAX_RANK];
03813 size_t edge[MAX_RANK];
03814 size_t mid[MAX_RANK];
03815 size_t index[MAX_RANK];
03816 int canConvert;
03817 int allInExtRange;
03818 long value[MAX_NELS];
03819
03820 err = nc_create(scratch, NC_CLOBBER, &ncid);
03821 IF (err) {
03822 error("nc_create: %s", nc_strerror(err));
03823 return;
03824 }
03825 def_dims(ncid);
03826 def_vars(ncid);
03827 err = nc_enddef(ncid);
03828 IF (err)
03829 error("nc_enddef: %s", nc_strerror(err));
03830
03831 value[0] = 0;
03832 for (i = 0; i < NVARS; i++) {
03833 canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
03834 assert(var_rank[i] <= MAX_RANK);
03835 assert(var_nels[i] <= MAX_NELS);
03836 for (j = 0; j < var_rank[i]; j++) {
03837 start[j] = 0;
03838 edge[j] = 1;
03839 }
03840 err = nc_put_vara_long(BAD_ID, i, start, edge, value);
03841 IF (err != NC_EBADID)
03842 error("bad ncid: status = %d", err);
03843 err = nc_put_vara_long(ncid, BAD_VARID, start, edge, value);
03844 IF (err != NC_ENOTVAR)
03845 error("bad var id: status = %d", err);
03846 for (j = 0; j < var_rank[i]; j++) {
03847 if (var_dimid[i][j] > 0) {
03848 start[j] = var_shape[i][j];
03849 err = nc_put_vara_long(ncid, i, start, edge, value);
03850 IF (canConvert && err != NC_EINVALCOORDS)
03851 error("bad start: status = %d", err);
03852 start[j] = 0;
03853 edge[j] = var_shape[i][j] + 1;
03854 err = nc_put_vara_long(ncid, i, start, edge, value);
03855 IF (canConvert && err != NC_EEDGE)
03856 error("bad edge: status = %d", err);
03857 edge[j] = 1;
03858 }
03859 }
03860
03861 for (j = 0; j < var_rank[i]; j++) {
03862 edge[j] = 0;
03863 }
03864 err = nc_put_vara_long(BAD_ID, i, start, edge, value);
03865 IF (err != NC_EBADID)
03866 error("bad ncid: status = %d", err);
03867 err = nc_put_vara_long(ncid, BAD_VARID, start, edge, value);
03868 IF (err != NC_ENOTVAR)
03869 error("bad var id: status = %d", err);
03870 for (j = 0; j < var_rank[i]; j++) {
03871 if (var_dimid[i][j] > 0) {
03872 start[j] = var_shape[i][j];
03873 err = nc_put_vara_long(ncid, i, start, edge, value);
03874 IF (canConvert && err != NC_EINVALCOORDS)
03875 error("bad start: status = %d", err);
03876 start[j] = 0;
03877 }
03878 }
03879 err = nc_put_vara_long(ncid, i, start, edge, value);
03880 if (canConvert) {
03881 IF (err)
03882 error("%s", nc_strerror(err));
03883 } else {
03884 IF (err != NC_ECHAR)
03885 error("wrong type: status = %d", err);
03886 }
03887 for (j = 0; j < var_rank[i]; j++) {
03888 edge[j] = 1;
03889 }
03890
03891
03892
03893 nslabs = 1;
03894 for (j = 0; j < var_rank[i]; j++) {
03895 mid[j] = roll( var_shape[i][j] );
03896 nslabs *= 2;
03897 }
03898
03899 for (k = 0; k < nslabs; k++) {
03900 nels = 1;
03901 for (j = 0; j < var_rank[i]; j++) {
03902 if ((k >> j) & 1) {
03903 start[j] = 0;
03904 edge[j] = mid[j];
03905 }else{
03906 start[j] = mid[j];
03907 edge[j] = var_shape[i][j] - mid[j];
03908 }
03909 nels *= edge[j];
03910 }
03911 for (allInExtRange = 1, j = 0; j < nels; j++) {
03912 err = toMixedBase(j, var_rank[i], edge, index);
03913 IF (err)
03914 error("error in toMixedBase 1");
03915 for (d = 0; d < var_rank[i]; d++)
03916 index[d] += start[d];
03917 value[j]= hash_long(var_type[i], var_rank[i], index, NCT_LONG);
03918 allInExtRange = allInExtRange
03919 && inRange3(value[j], var_type[i], NCT_LONG);
03920 }
03921 if (var_rank[i] == 0 && i%2 == 0)
03922 err = nc_put_vara_long(ncid, i, NULL, NULL, value);
03923 else
03924 err = nc_put_vara_long(ncid, i, start, edge, value);
03925 if (canConvert) {
03926 if (allInExtRange) {
03927 IF (err)
03928 error("%s", nc_strerror(err));
03929 } else {
03930 IF (err != NC_ERANGE)
03931 error("range error: status = %d", err);
03932 }
03933 } else {
03934 IF (nels > 0 && err != NC_ECHAR)
03935 error("wrong type: status = %d", err);
03936 }
03937 }
03938 }
03939
03940 err = nc_close(ncid);
03941 IF (err)
03942 error("nc_close: %s", nc_strerror(err));
03943
03944 check_vars_long(scratch);
03945
03946 err = remove(scratch);
03947 IF (err)
03948 error("remove of %s failed", scratch);
03949 }
03950
03951 void
03952 test_nc_put_vara_float(void)
03953 {
03954 int ncid;
03955 int d;
03956 int i;
03957 int j;
03958 int k;
03959 int err;
03960 int nslabs;
03961 int nels;
03962 size_t start[MAX_RANK];
03963 size_t edge[MAX_RANK];
03964 size_t mid[MAX_RANK];
03965 size_t index[MAX_RANK];
03966 int canConvert;
03967 int allInExtRange;
03968 float value[MAX_NELS];
03969
03970 err = nc_create(scratch, NC_CLOBBER, &ncid);
03971 IF (err) {
03972 error("nc_create: %s", nc_strerror(err));
03973 return;
03974 }
03975 def_dims(ncid);
03976 def_vars(ncid);
03977 err = nc_enddef(ncid);
03978 IF (err)
03979 error("nc_enddef: %s", nc_strerror(err));
03980
03981 value[0] = 0;
03982 for (i = 0; i < NVARS; i++) {
03983 canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
03984 assert(var_rank[i] <= MAX_RANK);
03985 assert(var_nels[i] <= MAX_NELS);
03986 for (j = 0; j < var_rank[i]; j++) {
03987 start[j] = 0;
03988 edge[j] = 1;
03989 }
03990 err = nc_put_vara_float(BAD_ID, i, start, edge, value);
03991 IF (err != NC_EBADID)
03992 error("bad ncid: status = %d", err);
03993 err = nc_put_vara_float(ncid, BAD_VARID, start, edge, value);
03994 IF (err != NC_ENOTVAR)
03995 error("bad var id: status = %d", err);
03996 for (j = 0; j < var_rank[i]; j++) {
03997 if (var_dimid[i][j] > 0) {
03998 start[j] = var_shape[i][j];
03999 err = nc_put_vara_float(ncid, i, start, edge, value);
04000 IF (canConvert && err != NC_EINVALCOORDS)
04001 error("bad start: status = %d", err);
04002 start[j] = 0;
04003 edge[j] = var_shape[i][j] + 1;
04004 err = nc_put_vara_float(ncid, i, start, edge, value);
04005 IF (canConvert && err != NC_EEDGE)
04006 error("bad edge: status = %d", err);
04007 edge[j] = 1;
04008 }
04009 }
04010
04011 for (j = 0; j < var_rank[i]; j++) {
04012 edge[j] = 0;
04013 }
04014 err = nc_put_vara_float(BAD_ID, i, start, edge, value);
04015 IF (err != NC_EBADID)
04016 error("bad ncid: status = %d", err);
04017 err = nc_put_vara_float(ncid, BAD_VARID, start, edge, value);
04018 IF (err != NC_ENOTVAR)
04019 error("bad var id: status = %d", err);
04020 for (j = 0; j < var_rank[i]; j++) {
04021 if (var_dimid[i][j] > 0) {
04022 start[j] = var_shape[i][j];
04023 err = nc_put_vara_float(ncid, i, start, edge, value);
04024 IF (canConvert && err != NC_EINVALCOORDS)
04025 error("bad start: status = %d", err);
04026 start[j] = 0;
04027 }
04028 }
04029 err = nc_put_vara_float(ncid, i, start, edge, value);
04030 if (canConvert) {
04031 IF (err)
04032 error("%s", nc_strerror(err));
04033 } else {
04034 IF (err != NC_ECHAR)
04035 error("wrong type: status = %d", err);
04036 }
04037 for (j = 0; j < var_rank[i]; j++) {
04038 edge[j] = 1;
04039 }
04040
04041
04042
04043 nslabs = 1;
04044 for (j = 0; j < var_rank[i]; j++) {
04045 mid[j] = roll( var_shape[i][j] );
04046 nslabs *= 2;
04047 }
04048
04049 for (k = 0; k < nslabs; k++) {
04050 nels = 1;
04051 for (j = 0; j < var_rank[i]; j++) {
04052 if ((k >> j) & 1) {
04053 start[j] = 0;
04054 edge[j] = mid[j];
04055 }else{
04056 start[j] = mid[j];
04057 edge[j] = var_shape[i][j] - mid[j];
04058 }
04059 nels *= edge[j];
04060 }
04061 for (allInExtRange = 1, j = 0; j < nels; j++) {
04062 err = toMixedBase(j, var_rank[i], edge, index);
04063 IF (err)
04064 error("error in toMixedBase 1");
04065 for (d = 0; d < var_rank[i]; d++)
04066 index[d] += start[d];
04067 value[j]= hash_float(var_type[i], var_rank[i], index, NCT_FLOAT);
04068 allInExtRange = allInExtRange
04069 && inRange3(value[j], var_type[i], NCT_FLOAT);
04070 }
04071 if (var_rank[i] == 0 && i%2 == 0)
04072 err = nc_put_vara_float(ncid, i, NULL, NULL, value);
04073 else
04074 err = nc_put_vara_float(ncid, i, start, edge, value);
04075 if (canConvert) {
04076 if (allInExtRange) {
04077 IF (err)
04078 error("%s", nc_strerror(err));
04079 } else {
04080 IF (err != NC_ERANGE)
04081 error("range error: status = %d", err);
04082 }
04083 } else {
04084 IF (nels > 0 && err != NC_ECHAR)
04085 error("wrong type: status = %d", err);
04086 }
04087 }
04088 }
04089
04090 err = nc_close(ncid);
04091 IF (err)
04092 error("nc_close: %s", nc_strerror(err));
04093
04094 check_vars_float(scratch);
04095
04096 err = remove(scratch);
04097 IF (err)
04098 error("remove of %s failed", scratch);
04099 }
04100
04101 void
04102 test_nc_put_vara_double(void)
04103 {
04104 int ncid;
04105 int d;
04106 int i;
04107 int j;
04108 int k;
04109 int err;
04110 int nslabs;
04111 int nels;
04112 size_t start[MAX_RANK];
04113 size_t edge[MAX_RANK];
04114 size_t mid[MAX_RANK];
04115 size_t index[MAX_RANK];
04116 int canConvert;
04117 int allInExtRange;
04118 double value[MAX_NELS];
04119
04120 err = nc_create(scratch, NC_CLOBBER, &ncid);
04121 IF (err) {
04122 error("nc_create: %s", nc_strerror(err));
04123 return;
04124 }
04125 def_dims(ncid);
04126 def_vars(ncid);
04127 err = nc_enddef(ncid);
04128 IF (err)
04129 error("nc_enddef: %s", nc_strerror(err));
04130
04131 value[0] = 0;
04132 for (i = 0; i < NVARS; i++) {
04133 canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
04134 assert(var_rank[i] <= MAX_RANK);
04135 assert(var_nels[i] <= MAX_NELS);
04136 for (j = 0; j < var_rank[i]; j++) {
04137 start[j] = 0;
04138 edge[j] = 1;
04139 }
04140 err = nc_put_vara_double(BAD_ID, i, start, edge, value);
04141 IF (err != NC_EBADID)
04142 error("bad ncid: status = %d", err);
04143 err = nc_put_vara_double(ncid, BAD_VARID, start, edge, value);
04144 IF (err != NC_ENOTVAR)
04145 error("bad var id: status = %d", err);
04146 for (j = 0; j < var_rank[i]; j++) {
04147 if (var_dimid[i][j] > 0) {
04148 start[j] = var_shape[i][j];
04149 err = nc_put_vara_double(ncid, i, start, edge, value);
04150 IF (canConvert && err != NC_EINVALCOORDS)
04151 error("bad start: status = %d", err);
04152 start[j] = 0;
04153 edge[j] = var_shape[i][j] + 1;
04154 err = nc_put_vara_double(ncid, i, start, edge, value);
04155 IF (canConvert && err != NC_EEDGE)
04156 error("bad edge: status = %d", err);
04157 edge[j] = 1;
04158 }
04159 }
04160
04161 for (j = 0; j < var_rank[i]; j++) {
04162 edge[j] = 0;
04163 }
04164 err = nc_put_vara_double(BAD_ID, i, start, edge, value);
04165 IF (err != NC_EBADID)
04166 error("bad ncid: status = %d", err);
04167 err = nc_put_vara_double(ncid, BAD_VARID, start, edge, value);
04168 IF (err != NC_ENOTVAR)
04169 error("bad var id: status = %d", err);
04170 for (j = 0; j < var_rank[i]; j++) {
04171 if (var_dimid[i][j] > 0) {
04172 start[j] = var_shape[i][j];
04173 err = nc_put_vara_double(ncid, i, start, edge, value);
04174 IF (canConvert && err != NC_EINVALCOORDS)
04175 error("bad start: status = %d", err);
04176 start[j] = 0;
04177 }
04178 }
04179 err = nc_put_vara_double(ncid, i, start, edge, value);
04180 if (canConvert) {
04181 IF (err)
04182 error("%s", nc_strerror(err));
04183 } else {
04184 IF (err != NC_ECHAR)
04185 error("wrong type: status = %d", err);
04186 }
04187 for (j = 0; j < var_rank[i]; j++) {
04188 edge[j] = 1;
04189 }
04190
04191
04192
04193 nslabs = 1;
04194 for (j = 0; j < var_rank[i]; j++) {
04195 mid[j] = roll( var_shape[i][j] );
04196 nslabs *= 2;
04197 }
04198
04199 for (k = 0; k < nslabs; k++) {
04200 nels = 1;
04201 for (j = 0; j < var_rank[i]; j++) {
04202 if ((k >> j) & 1) {
04203 start[j] = 0;
04204 edge[j] = mid[j];
04205 }else{
04206 start[j] = mid[j];
04207 edge[j] = var_shape[i][j] - mid[j];
04208 }
04209 nels *= edge[j];
04210 }
04211 for (allInExtRange = 1, j = 0; j < nels; j++) {
04212 err = toMixedBase(j, var_rank[i], edge, index);
04213 IF (err)
04214 error("error in toMixedBase 1");
04215 for (d = 0; d < var_rank[i]; d++)
04216 index[d] += start[d];
04217 value[j]= hash_double(var_type[i], var_rank[i], index,