PageRenderTime 91ms CodeModel.GetById 36ms RepoModel.GetById 0ms app.codeStats 1ms

/other/netcdf_write_matrix/src/nc_test/test_get.m4

http://github.com/jbeezley/wrf-fire
m4 | 900 lines | 869 code | 30 blank | 1 comment | 0 complexity | ba5b8c26795ef2e9b19bd1fd43364d9b MD5 | raw file
Possible License(s): AGPL-1.0
  1. dnl This is m4 source.
  2. dnl Process using m4 to produce 'C' language file.
  3. dnl
  4. dnl If you see this line, you can ignore the next one.
  5. /* Do not edit this file. It is produced from the corresponding .m4 source */
  6. dnl
  7. /*********************************************************************
  8. * Copyright 1996, UCAR/Unidata
  9. * See netcdf/COPYRIGHT file for copying and redistribution conditions.
  10. * $Id: test_get.m4,v 1.16 2005/03/08 03:04:19 ed Exp $
  11. *********************************************************************/
  12. undefine(`index')dnl
  13. dnl dnl dnl
  14. dnl
  15. dnl Macros
  16. dnl
  17. dnl dnl dnl
  18. dnl
  19. dnl Upcase(str)
  20. dnl
  21. define(`Upcase',dnl
  22. `dnl
  23. translit($1, abcdefghijklmnopqrstuvwxyz, ABCDEFGHIJKLMNOPQRSTUVWXYZ)')dnl
  24. dnl dnl dnl
  25. dnl
  26. dnl NCT_ITYPE(type)
  27. dnl
  28. define(`NCT_ITYPE', ``NCT_'Upcase($1)')dnl
  29. dnl
  30. #include "tests.h"
  31. dnl TEST_NC_GET_VAR1(TYPE)
  32. dnl
  33. define(`TEST_NC_GET_VAR1',dnl
  34. `dnl
  35. void
  36. test_nc_get_var1_$1(void)
  37. {
  38. int ncid;
  39. int i;
  40. int j;
  41. int err;
  42. int nok = 0; /* count of valid comparisons */
  43. size_t index[MAX_RANK];
  44. double expect;
  45. int canConvert; /* Both text or both numeric */
  46. $1 value;
  47. err = nc_open(testfile, NC_NOWRITE, &ncid);
  48. IF (err)
  49. error("nc_open: %s", nc_strerror(err));
  50. for (i = 0; i < NVARS; i++) {
  51. canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
  52. for (j = 0; j < var_rank[i]; j++)
  53. index[j] = 0;
  54. err = nc_get_var1_$1(BAD_ID, i, index, &value);
  55. IF (err != NC_EBADID)
  56. error("bad ncid: status = %d", err);
  57. err = nc_get_var1_$1(ncid, BAD_VARID, index, &value);
  58. IF (err != NC_ENOTVAR)
  59. error("bad var id: status = %d", err);
  60. for (j = 0; j < var_rank[i]; j++) {
  61. index[j] = var_shape[i][j];
  62. err = nc_get_var1_$1(ncid, i, index, &value);
  63. if(!canConvert) {
  64. IF(err != NC_ECHAR)
  65. error("conversion: status = %d", err);
  66. } else IF (err != NC_EINVALCOORDS)
  67. error("bad index: status = %d", err);
  68. index[j] = 0;
  69. }
  70. for (j = 0; j < var_nels[i]; j++) {
  71. err = toMixedBase(j, var_rank[i], var_shape[i], index);
  72. IF (err)
  73. error("error in toMixedBase 1");
  74. expect = hash4( var_type[i], var_rank[i], index, NCT_ITYPE($1) );
  75. if (var_rank[i] == 0 && i%2 )
  76. err = nc_get_var1_$1(ncid, i, NULL, &value);
  77. else
  78. err = nc_get_var1_$1(ncid, i, index, &value);
  79. if (canConvert) {
  80. if (inRange3(expect,var_type[i], NCT_ITYPE($1))) {
  81. if (expect >= $1_min && expect <= $1_max) {
  82. IF (err) {
  83. error("%s", nc_strerror(err));
  84. } else {
  85. IF (!equal(value,expect,var_type[i],NCT_ITYPE($1))) {
  86. error("expected: %G, got: %G", expect,
  87. (double) value);
  88. } else {
  89. nok++;
  90. }
  91. }
  92. } else {
  93. IF (err != NC_ERANGE)
  94. error("Range error: status = %d", err);
  95. }
  96. } else {
  97. IF (err != 0 && err != NC_ERANGE)
  98. error("OK or Range error: status = %d", err);
  99. }
  100. } else {
  101. IF (err != NC_ECHAR)
  102. error("wrong type: status = %d", err);
  103. }
  104. }
  105. }
  106. err = nc_close(ncid);
  107. IF (err)
  108. error("nc_close: %s", nc_strerror(err));
  109. print_nok(nok);
  110. }
  111. ')dnl
  112. TEST_NC_GET_VAR1(text)
  113. TEST_NC_GET_VAR1(uchar)
  114. TEST_NC_GET_VAR1(schar)
  115. TEST_NC_GET_VAR1(short)
  116. TEST_NC_GET_VAR1(int)
  117. TEST_NC_GET_VAR1(long)
  118. TEST_NC_GET_VAR1(float)
  119. TEST_NC_GET_VAR1(double)
  120. dnl TEST_NC_GET_VAR(TYPE)
  121. dnl
  122. define(`TEST_NC_GET_VAR',dnl
  123. `dnl
  124. void
  125. test_nc_get_var_$1(void)
  126. {
  127. int ncid;
  128. int i;
  129. int j;
  130. int err;
  131. int allInExtRange; /* all values within external range? */
  132. int allInIntRange; /* all values within internal range? */
  133. int nels;
  134. int nok = 0; /* count of valid comparisons */
  135. size_t index[MAX_RANK];
  136. int canConvert; /* Both text or both numeric */
  137. $1 value[MAX_NELS];
  138. double expect[MAX_NELS];
  139. err = nc_open(testfile, NC_NOWRITE, &ncid);
  140. IF (err)
  141. error("nc_open: %s", nc_strerror(err));
  142. for (i = 0; i < NVARS; i++) {
  143. canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
  144. assert(var_rank[i] <= MAX_RANK);
  145. assert(var_nels[i] <= MAX_NELS);
  146. err = nc_get_var_$1(BAD_ID, i, value);
  147. IF (err != NC_EBADID)
  148. error("bad ncid: status = %d", err);
  149. err = nc_get_var_$1(ncid, BAD_VARID, value);
  150. IF (err != NC_ENOTVAR)
  151. error("bad var id: status = %d", err);
  152. nels = 1;
  153. for (j = 0; j < var_rank[i]; j++) {
  154. nels *= var_shape[i][j];
  155. }
  156. allInExtRange = allInIntRange = 1;
  157. for (j = 0; j < nels; j++) {
  158. err = toMixedBase(j, var_rank[i], var_shape[i], index);
  159. IF (err)
  160. error("error in toMixedBase 1");
  161. expect[j] = hash4(var_type[i], var_rank[i], index, NCT_ITYPE($1));
  162. if (inRange3(expect[j],var_type[i], NCT_ITYPE($1))) {
  163. allInIntRange = allInIntRange && expect[j] >= $1_min
  164. && expect[j] <= $1_max;
  165. } else {
  166. allInExtRange = 0;
  167. }
  168. }
  169. err = nc_get_var_$1(ncid, i, value);
  170. if (canConvert) {
  171. if (allInExtRange) {
  172. if (allInIntRange) {
  173. IF (err)
  174. error("%s", nc_strerror(err));
  175. } else {
  176. IF (err != NC_ERANGE)
  177. error("Range error: status = %d", err);
  178. }
  179. } else {
  180. IF (err != 0 && err != NC_ERANGE)
  181. error("OK or Range error: status = %d", err);
  182. }
  183. for (j = 0; j < nels; j++) {
  184. if (inRange3(expect[j],var_type[i],NCT_ITYPE($1))
  185. && expect[j] >= $1_min && expect[j] <= $1_max) {
  186. IF (!equal(value[j],expect[j],var_type[i],NCT_ITYPE($1))){
  187. error("value read not that expected");
  188. if (verbose) {
  189. error("\n");
  190. error("varid: %d, ", i);
  191. error("var_name: %s, ", var_name[i]);
  192. error("element number: %d ", j);
  193. error("expect: %g", expect[j]);
  194. error("got: %g", (double) value[j]);
  195. }
  196. } else {
  197. nok++;
  198. }
  199. }
  200. }
  201. } else {
  202. IF (nels > 0 && err != NC_ECHAR)
  203. error("wrong type: status = %d", err);
  204. }
  205. }
  206. err = nc_close(ncid);
  207. IF (err)
  208. error("nc_close: %s", nc_strerror(err));
  209. print_nok(nok);
  210. }
  211. ')dnl
  212. TEST_NC_GET_VAR(text)
  213. TEST_NC_GET_VAR(uchar)
  214. TEST_NC_GET_VAR(schar)
  215. TEST_NC_GET_VAR(short)
  216. TEST_NC_GET_VAR(int)
  217. TEST_NC_GET_VAR(long)
  218. TEST_NC_GET_VAR(float)
  219. TEST_NC_GET_VAR(double)
  220. dnl TEST_NC_GET_VARA(TYPE)
  221. dnl
  222. define(`TEST_NC_GET_VARA',dnl
  223. `dnl
  224. void
  225. test_nc_get_vara_$1(void)
  226. {
  227. int ncid;
  228. int d;
  229. int i;
  230. int j;
  231. int k;
  232. int err;
  233. int allInExtRange; /* all values within external range? */
  234. int allInIntRange; /* all values within internal range? */
  235. int nels;
  236. int nslabs;
  237. int nok = 0; /* count of valid comparisons */
  238. size_t start[MAX_RANK];
  239. size_t edge[MAX_RANK];
  240. size_t index[MAX_RANK];
  241. size_t mid[MAX_RANK];
  242. int canConvert; /* Both text or both numeric */
  243. $1 value[MAX_NELS];
  244. double expect[MAX_NELS];
  245. err = nc_open(testfile, NC_NOWRITE, &ncid);
  246. IF (err)
  247. error("nc_open: %s", nc_strerror(err));
  248. for (i = 0; i < NVARS; i++) {
  249. canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
  250. assert(var_rank[i] <= MAX_RANK);
  251. assert(var_nels[i] <= MAX_NELS);
  252. for (j = 0; j < var_rank[i]; j++) {
  253. start[j] = 0;
  254. edge[j] = 1;
  255. }
  256. err = nc_get_vara_$1(BAD_ID, i, start, edge, value);
  257. IF (err != NC_EBADID)
  258. error("bad ncid: status = %d", err);
  259. err = nc_get_vara_$1(ncid, BAD_VARID, start, edge, value);
  260. IF (err != NC_ENOTVAR)
  261. error("bad var id: status = %d", err);
  262. for (j = 0; j < var_rank[i]; j++) {
  263. start[j] = var_shape[i][j];
  264. err = nc_get_vara_$1(ncid, i, start, edge, value);
  265. IF (canConvert && err != NC_EINVALCOORDS)
  266. error("bad index: status = %d", err);
  267. start[j] = 0;
  268. edge[j] = var_shape[i][j] + 1;
  269. err = nc_get_vara_$1(ncid, i, start, edge, value);
  270. IF (canConvert && err != NC_EEDGE)
  271. error("bad edge: status = %d", err);
  272. edge[j] = 1;
  273. }
  274. /* Check non-scalars for correct error returned even when */
  275. /* there is nothing to get (edge[j]==0) */
  276. if(var_rank[i] > 0) {
  277. for (j = 0; j < var_rank[i]; j++) {
  278. edge[j] = 0;
  279. }
  280. err = nc_get_vara_$1(BAD_ID, i, start, edge, value);
  281. IF (err != NC_EBADID)
  282. error("bad ncid: status = %d", err);
  283. err = nc_get_vara_$1(ncid, BAD_VARID, start, edge, value);
  284. IF (err != NC_ENOTVAR)
  285. error("bad var id: status = %d", err);
  286. for (j = 0; j < var_rank[i]; j++) {
  287. if (var_dimid[i][j] > 0) { /* skip record dim */
  288. start[j] = var_shape[i][j];
  289. err = nc_get_vara_$1(ncid, i, start, edge, value);
  290. IF (canConvert && err != NC_EINVALCOORDS)
  291. error("bad start: status = %d", err);
  292. start[j] = 0;
  293. }
  294. }
  295. err = nc_get_vara_$1(ncid, i, start, edge, value);
  296. if (canConvert) {
  297. IF (err)
  298. error("%s", nc_strerror(err));
  299. } else {
  300. IF (err != NC_ECHAR)
  301. error("wrong type: status = %d", err);
  302. }
  303. for (j = 0; j < var_rank[i]; j++) {
  304. edge[j] = 1;
  305. }
  306. } /* Choose a random point dividing each dim into 2 parts */
  307. /* get 2^rank (nslabs) slabs so defined */
  308. nslabs = 1;
  309. for (j = 0; j < var_rank[i]; j++) {
  310. mid[j] = roll( var_shape[i][j] );
  311. nslabs *= 2;
  312. }
  313. /* bits of k determine whether to get lower or upper part of dim */
  314. for (k = 0; k < nslabs; k++) {
  315. nels = 1;
  316. for (j = 0; j < var_rank[i]; j++) {
  317. if ((k >> j) & 1) {
  318. start[j] = 0;
  319. edge[j] = mid[j];
  320. }else{
  321. start[j] = mid[j];
  322. edge[j] = var_shape[i][j] - mid[j];
  323. }
  324. nels *= edge[j];
  325. }
  326. allInExtRange = allInIntRange = 1;
  327. for (j = 0; j < nels; j++) {
  328. err = toMixedBase(j, var_rank[i], edge, index);
  329. IF (err)
  330. error("error in toMixedBase 1");
  331. for (d = 0; d < var_rank[i]; d++)
  332. index[d] += start[d];
  333. expect[j] = hash4(var_type[i], var_rank[i], index, NCT_ITYPE($1));
  334. if (inRange3(expect[j],var_type[i], NCT_ITYPE($1))) {
  335. allInIntRange = allInIntRange && expect[j] >= $1_min
  336. && expect[j] <= $1_max;
  337. } else {
  338. allInExtRange = 0;
  339. }
  340. }
  341. if (var_rank[i] == 0 && i%2)
  342. err = nc_get_vara_$1(ncid, i, NULL, NULL, value);
  343. else
  344. err = nc_get_vara_$1(ncid, i, start, edge, value);
  345. if (canConvert) {
  346. if (allInExtRange) {
  347. if (allInIntRange) {
  348. IF (err)
  349. error("%s", nc_strerror(err));
  350. } else {
  351. IF (err != NC_ERANGE)
  352. error("Range error: status = %d", err);
  353. }
  354. } else {
  355. IF (err != 0 && err != NC_ERANGE)
  356. error("OK or Range error: status = %d", err);
  357. }
  358. for (j = 0; j < nels; j++) {
  359. if (inRange3(expect[j],var_type[i],NCT_ITYPE($1))
  360. && expect[j] >= $1_min && expect[j] <= $1_max) {
  361. IF (!equal(value[j],expect[j],var_type[i],NCT_ITYPE($1))){
  362. error("value read not that expected");
  363. if (verbose) {
  364. error("\n");
  365. error("varid: %d, ", i);
  366. error("var_name: %s, ", var_name[i]);
  367. error("element number: %d ", j);
  368. error("expect: %g", expect[j]);
  369. error("got: %g", (double) value[j]);
  370. }
  371. } else {
  372. nok++;
  373. }
  374. }
  375. }
  376. } else {
  377. IF (nels > 0 && err != NC_ECHAR)
  378. error("wrong type: status = %d", err);
  379. }
  380. }
  381. }
  382. err = nc_close(ncid);
  383. IF (err)
  384. error("nc_close: %s", nc_strerror(err));
  385. print_nok(nok);
  386. }
  387. ')dnl
  388. TEST_NC_GET_VARA(text)
  389. TEST_NC_GET_VARA(uchar)
  390. TEST_NC_GET_VARA(schar)
  391. TEST_NC_GET_VARA(short)
  392. TEST_NC_GET_VARA(int)
  393. TEST_NC_GET_VARA(long)
  394. TEST_NC_GET_VARA(float)
  395. TEST_NC_GET_VARA(double)
  396. dnl TEST_NC_GET_VARS(TYPE)
  397. dnl
  398. define(`TEST_NC_GET_VARS',dnl
  399. `dnl
  400. void
  401. test_nc_get_vars_$1(void)
  402. {
  403. int ncid;
  404. int d;
  405. int i;
  406. int j;
  407. int k;
  408. int m;
  409. int err;
  410. int allInExtRange; /* all values within external range? */
  411. int allInIntRange; /* all values within internal range? */
  412. int nels;
  413. int nslabs;
  414. int nstarts; /* number of different starts */
  415. int nok = 0; /* count of valid comparisons */
  416. size_t start[MAX_RANK];
  417. size_t edge[MAX_RANK];
  418. size_t index[MAX_RANK];
  419. size_t index2[MAX_RANK];
  420. size_t mid[MAX_RANK];
  421. size_t count[MAX_RANK];
  422. size_t sstride[MAX_RANK];
  423. ptrdiff_t stride[MAX_RANK];
  424. int canConvert; /* Both text or both numeric */
  425. $1 value[MAX_NELS];
  426. double expect[MAX_NELS];
  427. err = nc_open(testfile, NC_NOWRITE, &ncid);
  428. IF (err)
  429. error("nc_open: %s", nc_strerror(err));
  430. for (i = 0; i < NVARS; i++) {
  431. canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
  432. assert(var_rank[i] <= MAX_RANK);
  433. assert(var_nels[i] <= MAX_NELS);
  434. for (j = 0; j < var_rank[i]; j++) {
  435. start[j] = 0;
  436. edge[j] = 1;
  437. stride[j] = 1;
  438. }
  439. err = nc_get_vars_$1(BAD_ID, i, start, edge, stride, value);
  440. IF (err != NC_EBADID)
  441. error("bad ncid: status = %d", err);
  442. err = nc_get_vars_$1(ncid, BAD_VARID, start, edge, stride, value);
  443. IF (err != NC_ENOTVAR)
  444. error("bad var id: status = %d", err);
  445. for (j = 0; j < var_rank[i]; j++) {
  446. start[j] = var_shape[i][j];
  447. err = nc_get_vars_$1(ncid, i, start, edge, stride, value);
  448. if(!canConvert) {
  449. IF (err != NC_ECHAR)
  450. error("conversion: status = %d", err);
  451. } else {
  452. IF (err != NC_EINVALCOORDS)
  453. error("bad index: status = %d", err);
  454. start[j] = 0;
  455. edge[j] = var_shape[i][j] + 1;
  456. err = nc_get_vars_$1(ncid, i, start, edge, stride, value);
  457. IF (err != NC_EEDGE)
  458. error("bad edge: status = %d", err);
  459. edge[j] = 1;
  460. stride[j] = 0;
  461. err = nc_get_vars_$1(ncid, i, start, edge, stride, value);
  462. IF (err != NC_ESTRIDE)
  463. error("bad stride: status = %d", err);
  464. stride[j] = 1;
  465. }
  466. }
  467. /* Choose a random point dividing each dim into 2 parts */
  468. /* get 2^rank (nslabs) slabs so defined */
  469. nslabs = 1;
  470. for (j = 0; j < var_rank[i]; j++) {
  471. mid[j] = roll( var_shape[i][j] );
  472. nslabs *= 2;
  473. }
  474. /* bits of k determine whether to get lower or upper part of dim */
  475. /* choose random stride from 1 to edge */
  476. for (k = 0; k < nslabs; k++) {
  477. nstarts = 1;
  478. for (j = 0; j < var_rank[i]; j++) {
  479. if ((k >> j) & 1) {
  480. start[j] = 0;
  481. edge[j] = mid[j];
  482. }else{
  483. start[j] = mid[j];
  484. edge[j] = var_shape[i][j] - mid[j];
  485. }
  486. sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
  487. nstarts *= stride[j];
  488. }
  489. for (m = 0; m < nstarts; m++) {
  490. err = toMixedBase(m, var_rank[i], sstride, index);
  491. IF (err)
  492. error("error in toMixedBase");
  493. nels = 1;
  494. for (j = 0; j < var_rank[i]; j++) {
  495. count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
  496. nels *= count[j];
  497. index[j] += start[j];
  498. }
  499. /* Random choice of forward or backward */
  500. /* TODO
  501. if ( roll(2) ) {
  502. for (j = 0; j < var_rank[i]; j++) {
  503. index[j] += (count[j] - 1) * stride[j];
  504. stride[j] = -stride[j];
  505. }
  506. }
  507. */
  508. allInExtRange = allInIntRange = 1;
  509. for (j = 0; j < nels; j++) {
  510. err = toMixedBase(j, var_rank[i], count, index2);
  511. IF (err)
  512. error("error in toMixedBase 1");
  513. for (d = 0; d < var_rank[i]; d++)
  514. index2[d] = index[d] + index2[d] * stride[d];
  515. expect[j] = hash4(var_type[i], var_rank[i], index2,
  516. NCT_ITYPE($1));
  517. if (inRange3(expect[j],var_type[i],NCT_ITYPE($1))) {
  518. allInIntRange = allInIntRange && expect[j] >= $1_min
  519. && expect[j] <= $1_max;
  520. } else {
  521. allInExtRange = 0;
  522. }
  523. }
  524. if (var_rank[i] == 0 && i%2 )
  525. err = nc_get_vars_$1(ncid, i, NULL, NULL, NULL, value);
  526. else
  527. err = nc_get_vars_$1(ncid, i, index, count, stride, value);
  528. if (canConvert) {
  529. if (allInExtRange) {
  530. if (allInIntRange) {
  531. IF (err)
  532. error("%s", nc_strerror(err));
  533. } else {
  534. IF (err != NC_ERANGE)
  535. error("Range error: status = %d", err);
  536. }
  537. } else {
  538. IF (err != 0 && err != NC_ERANGE)
  539. error("OK or Range error: status = %d", err);
  540. }
  541. for (j = 0; j < nels; j++) {
  542. if (inRange3(expect[j],var_type[i],NCT_ITYPE($1))
  543. && expect[j] >= $1_min && expect[j] <= $1_max) {
  544. IF (!equal(value[j],expect[j],var_type[i],
  545. NCT_ITYPE($1))){
  546. error("value read not that expected");
  547. if (verbose) {
  548. error("\n");
  549. error("varid: %d, ", i);
  550. error("var_name: %s, ", var_name[i]);
  551. error("element number: %d ", j);
  552. error("expect: %g, ", expect[j]);
  553. error("got: %g", (double) value[j]);
  554. }
  555. } else {
  556. nok++;
  557. }
  558. }
  559. }
  560. } else {
  561. IF (nels > 0 && err != NC_ECHAR)
  562. error("wrong type: status = %d", err);
  563. }
  564. }
  565. }
  566. }
  567. err = nc_close(ncid);
  568. IF (err)
  569. error("nc_close: %s", nc_strerror(err));
  570. print_nok(nok);
  571. }
  572. ')dnl
  573. TEST_NC_GET_VARS(text)
  574. TEST_NC_GET_VARS(uchar)
  575. TEST_NC_GET_VARS(schar)
  576. TEST_NC_GET_VARS(short)
  577. TEST_NC_GET_VARS(int)
  578. TEST_NC_GET_VARS(long)
  579. TEST_NC_GET_VARS(float)
  580. TEST_NC_GET_VARS(double)
  581. dnl TEST_NC_GET_VARM(TYPE)
  582. dnl
  583. define(`TEST_NC_GET_VARM',dnl
  584. `dnl
  585. void
  586. test_nc_get_varm_$1(void)
  587. {
  588. int ncid;
  589. int d;
  590. int i;
  591. int j;
  592. int k;
  593. int m;
  594. int err;
  595. int allInExtRange; /* all values within external range? */
  596. int allInIntRange; /* all values within internal range? */
  597. int nels;
  598. int nslabs;
  599. int nstarts; /* number of different starts */
  600. int nok = 0; /* count of valid comparisons */
  601. size_t start[MAX_RANK];
  602. size_t edge[MAX_RANK];
  603. size_t index[MAX_RANK];
  604. size_t index2[MAX_RANK];
  605. size_t mid[MAX_RANK];
  606. size_t count[MAX_RANK];
  607. size_t sstride[MAX_RANK];
  608. ptrdiff_t stride[MAX_RANK];
  609. ptrdiff_t imap[MAX_RANK];
  610. int canConvert; /* Both text or both numeric */
  611. $1 value[MAX_NELS];
  612. double expect[MAX_NELS];
  613. err = nc_open(testfile, NC_NOWRITE, &ncid);
  614. IF (err)
  615. error("nc_open: %s", nc_strerror(err));
  616. for (i = 0; i < NVARS; i++) {
  617. canConvert = (var_type[i] == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
  618. assert(var_rank[i] <= MAX_RANK);
  619. assert(var_nels[i] <= MAX_NELS);
  620. for (j = 0; j < var_rank[i]; j++) {
  621. start[j] = 0;
  622. edge[j] = 1;
  623. stride[j] = 1;
  624. imap[j] = 1;
  625. }
  626. err = nc_get_varm_$1(BAD_ID, i, start, edge, stride, imap, value);
  627. IF (err != NC_EBADID)
  628. error("bad ncid: status = %d", err);
  629. err = nc_get_varm_$1(ncid, BAD_VARID, start, edge, stride, imap, value);
  630. IF (err != NC_ENOTVAR)
  631. error("bad var id: status = %d", err);
  632. for (j = 0; j < var_rank[i]; j++) {
  633. start[j] = var_shape[i][j];
  634. err = nc_get_varm_$1(ncid, i, start, edge, stride, imap, value);
  635. if(!canConvert) {
  636. IF (err != NC_ECHAR)
  637. error("conversion: status = %d", err);
  638. } else {
  639. IF (err != NC_EINVALCOORDS)
  640. error("bad index: status = %d", err);
  641. start[j] = 0;
  642. edge[j] = var_shape[i][j] + 1;
  643. err = nc_get_varm_$1(ncid, i, start, edge, stride, imap, value);
  644. IF (err != NC_EEDGE)
  645. error("bad edge: status = %d", err);
  646. edge[j] = 1;
  647. stride[j] = 0;
  648. err = nc_get_varm_$1(ncid, i, start, edge, stride, imap, value);
  649. IF (err != NC_ESTRIDE)
  650. error("bad stride: status = %d", err);
  651. stride[j] = 1;
  652. }
  653. }
  654. /* Choose a random point dividing each dim into 2 parts */
  655. /* get 2^rank (nslabs) slabs so defined */
  656. nslabs = 1;
  657. for (j = 0; j < var_rank[i]; j++) {
  658. mid[j] = roll( var_shape[i][j] );
  659. nslabs *= 2;
  660. }
  661. /* bits of k determine whether to get lower or upper part of dim */
  662. /* choose random stride from 1 to edge */
  663. for (k = 0; k < nslabs; k++) {
  664. nstarts = 1;
  665. for (j = 0; j < var_rank[i]; j++) {
  666. if ((k >> j) & 1) {
  667. start[j] = 0;
  668. edge[j] = mid[j];
  669. }else{
  670. start[j] = mid[j];
  671. edge[j] = var_shape[i][j] - mid[j];
  672. }
  673. sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
  674. nstarts *= stride[j];
  675. }
  676. for (m = 0; m < nstarts; m++) {
  677. err = toMixedBase(m, var_rank[i], sstride, index);
  678. IF (err)
  679. error("error in toMixedBase");
  680. nels = 1;
  681. for (j = 0; j < var_rank[i]; j++) {
  682. count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
  683. nels *= count[j];
  684. index[j] += start[j];
  685. }
  686. /* Random choice of forward or backward */
  687. /* TODO
  688. if ( roll(2) ) {
  689. for (j = 0; j < var_rank[i]; j++) {
  690. index[j] += (count[j] - 1) * stride[j];
  691. stride[j] = -stride[j];
  692. }
  693. }
  694. */
  695. if (var_rank[i] > 0) {
  696. j = var_rank[i] - 1;
  697. imap[j] = 1;
  698. for (; j > 0; j--)
  699. imap[j-1] = imap[j] * count[j];
  700. }
  701. allInExtRange = allInIntRange = 1;
  702. for (j = 0; j < nels; j++) {
  703. err = toMixedBase(j, var_rank[i], count, index2);
  704. IF (err)
  705. error("error in toMixedBase 1");
  706. for (d = 0; d < var_rank[i]; d++)
  707. index2[d] = index[d] + index2[d] * stride[d];
  708. expect[j] = hash4(var_type[i], var_rank[i], index2,
  709. NCT_ITYPE($1));
  710. if (inRange3(expect[j],var_type[i],NCT_ITYPE($1))) {
  711. allInIntRange = allInIntRange && expect[j] >= $1_min
  712. && expect[j] <= $1_max;
  713. } else {
  714. allInExtRange = 0;
  715. }
  716. }
  717. if (var_rank[i] == 0 && i%2 )
  718. err = nc_get_varm_$1(ncid,i,NULL,NULL,NULL,NULL,value);
  719. else
  720. err = nc_get_varm_$1(ncid,i,index,count,stride,imap,value);
  721. if (canConvert) {
  722. if (allInExtRange) {
  723. if (allInIntRange) {
  724. IF (err)
  725. error("%s", nc_strerror(err));
  726. } else {
  727. IF (err != NC_ERANGE)
  728. error("Range error: status = %d", err);
  729. }
  730. } else {
  731. IF (err != 0 && err != NC_ERANGE)
  732. error("OK or Range error: status = %d", err);
  733. }
  734. for (j = 0; j < nels; j++) {
  735. if (inRange3(expect[j],var_type[i],NCT_ITYPE($1))
  736. && expect[j] >= $1_min
  737. && expect[j] <= $1_max) {
  738. IF (!equal(value[j],expect[j],var_type[i],
  739. NCT_ITYPE($1))){
  740. error("value read not that expected");
  741. if (verbose) {
  742. error("\n");
  743. error("varid: %d, ", i);
  744. error("var_name: %s, ", var_name[i]);
  745. error("element number: %d ", j);
  746. error("expect: %g, ", expect[j]);
  747. error("got: %g", (double) value[j]);
  748. }
  749. } else {
  750. nok++;
  751. }
  752. }
  753. }
  754. } else {
  755. IF (nels > 0 && err != NC_ECHAR)
  756. error("wrong type: status = %d", err);
  757. }
  758. }
  759. }
  760. }
  761. err = nc_close(ncid);
  762. IF (err)
  763. error("nc_close: %s", nc_strerror(err));
  764. print_nok(nok);
  765. }
  766. ')dnl
  767. TEST_NC_GET_VARM(text)
  768. TEST_NC_GET_VARM(uchar)
  769. TEST_NC_GET_VARM(schar)
  770. TEST_NC_GET_VARM(short)
  771. TEST_NC_GET_VARM(int)
  772. TEST_NC_GET_VARM(long)
  773. TEST_NC_GET_VARM(float)
  774. TEST_NC_GET_VARM(double)
  775. dnl TEST_NC_GET_ATT(TYPE)
  776. dnl
  777. define(`TEST_NC_GET_ATT',dnl
  778. `dnl
  779. void
  780. test_nc_get_att_$1(void)
  781. {
  782. int ncid;
  783. int i;
  784. int j;
  785. size_t k;
  786. int err;
  787. int allInExtRange;
  788. int allInIntRange;
  789. int canConvert; /* Both text or both numeric */
  790. $1 value[MAX_NELS];
  791. double expect[MAX_NELS];
  792. int nok = 0; /* count of valid comparisons */
  793. err = nc_open(testfile, NC_NOWRITE, &ncid);
  794. IF (err)
  795. error("nc_open: %s", nc_strerror(err));
  796. for (i = -1; i < NVARS; i++) {
  797. for (j = 0; j < NATTS(i); j++) {
  798. canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_ITYPE($1) == NCT_TEXT);
  799. err = nc_get_att_$1(BAD_ID, i, ATT_NAME(i,j), value);
  800. IF (err != NC_EBADID)
  801. error("bad ncid: status = %d", err);
  802. err = nc_get_att_$1(ncid, BAD_VARID, ATT_NAME(i,j), value);
  803. IF (err != NC_ENOTVAR)
  804. error("bad var id: status = %d", err);
  805. err = nc_get_att_$1(ncid, i, "noSuch", value);
  806. IF (err != NC_ENOTATT)
  807. error("Bad attribute name: status = %d", err);
  808. allInExtRange = allInIntRange = 1;
  809. for (k = 0; k < ATT_LEN(i,j); k++) {
  810. expect[k] = hash4(ATT_TYPE(i,j), -1, &k, NCT_ITYPE($1));
  811. if (inRange3(expect[k],ATT_TYPE(i,j),NCT_ITYPE($1))) {
  812. allInIntRange = allInIntRange && expect[k] >= $1_min
  813. && expect[k] <= $1_max;
  814. } else {
  815. allInExtRange = 0;
  816. }
  817. }
  818. err = nc_get_att_$1(ncid, i, ATT_NAME(i,j), value);
  819. if (canConvert || ATT_LEN(i,j) == 0) {
  820. if (allInExtRange) {
  821. if (allInIntRange) {
  822. IF (err)
  823. error("%s", nc_strerror(err));
  824. } else {
  825. IF (err != NC_ERANGE)
  826. error("Range error: status = %d", err);
  827. }
  828. } else {
  829. IF (err != 0 && err != NC_ERANGE)
  830. error("OK or Range error: status = %d", err);
  831. }
  832. for (k = 0; k < ATT_LEN(i,j); k++) {
  833. if (inRange3(expect[k],ATT_TYPE(i,j),NCT_ITYPE($1))
  834. && expect[k] >= $1_min && expect[k] <= $1_max) {
  835. IF (!equal(value[k],expect[k],ATT_TYPE(i,j),
  836. NCT_ITYPE($1))){
  837. error("value read not that expected");
  838. if (verbose) {
  839. error("\n");
  840. error("varid: %d, ", i);
  841. error("att_name: %s, ", ATT_NAME(i,j));
  842. error("element number: %d ", k);
  843. error("expect: %g", expect[k]);
  844. error("got: %g", (double) value[k]);
  845. }
  846. } else {
  847. nok++;
  848. }
  849. }
  850. }
  851. } else {
  852. IF (err != NC_ECHAR)
  853. error("wrong type: status = %d", err);
  854. }
  855. }
  856. }
  857. err = nc_close(ncid);
  858. IF (err)
  859. error("nc_close: %s", nc_strerror(err));
  860. print_nok(nok);
  861. }
  862. ')dnl
  863. TEST_NC_GET_ATT(text)
  864. TEST_NC_GET_ATT(uchar)
  865. TEST_NC_GET_ATT(schar)
  866. TEST_NC_GET_ATT(short)
  867. TEST_NC_GET_ATT(int)
  868. TEST_NC_GET_ATT(long)
  869. TEST_NC_GET_ATT(float)
  870. TEST_NC_GET_ATT(double)