1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 2 * Copyright by The HDF Group. * 3 * Copyright by the Board of Trustees of the University of Illinois. * 4 * All rights reserved. * 5 * * 6 * This file is part of HDF5. The full HDF5 copyright notice, including * 7 * terms governing use, modification, and redistribution, is contained in * 8 * the COPYING file, which can be found at the root of the source code * 9 * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. * 10 * If you do not have access to either file, you may request a copy from * 11 * help@hdfgroup.org. * 12 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 13 14 package test; 15 16 import static org.junit.Assert.assertFalse; 17 import static org.junit.Assert.assertTrue; 18 import static org.junit.Assert.fail; 19 20 import java.io.File; 21 22 import hdf.hdf5lib.H5; 23 import hdf.hdf5lib.HDF5Constants; 24 import hdf.hdf5lib.HDFNativeData; 25 import hdf.hdf5lib.callbacks.H5D_iterate_cb; 26 import hdf.hdf5lib.callbacks.H5D_iterate_t; 27 import hdf.hdf5lib.exceptions.HDF5Exception; 28 import hdf.hdf5lib.exceptions.HDF5LibraryException; 29 30 import org.junit.After; 31 import org.junit.Before; 32 import org.junit.Rule; 33 import org.junit.Test; 34 import org.junit.rules.TestName; 35 36 public class TestH5D { 37 @Rule public TestName testname = new TestName(); 38 private static final String H5_FILE = "testD.h5"; 39 private static final int DIM_X = 4; 40 private static final int DIM_Y = 6; 41 private static final int RANK = 2; 42 long H5fid = -1; 43 long H5faplid = -1; 44 long H5dsid = -1; 45 long H5dtid = -1; 46 long H5did = -1; 47 long H5did0 = -1; 48 long H5dcpl_id = -1; 49 long[] H5dims = { DIM_X, DIM_Y }; 50 51 // Values for the status of space allocation 52 enum H5D_space_status { 53 H5D_SPACE_STATUS_ERROR(-1), H5D_SPACE_STATUS_NOT_ALLOCATED(0), H5D_SPACE_STATUS_PART_ALLOCATED( 54 1), H5D_SPACE_STATUS_ALLOCATED(2); 55 56 private int code; 57 H5D_space_status(int space_status)58 H5D_space_status(int space_status) { 59 this.code = space_status; 60 } 61 getCode()62 public int getCode() { 63 return this.code; 64 } 65 } 66 _deleteFile(String filename)67 private final void _deleteFile(String filename) { 68 File file = new File(filename); 69 70 if (file.exists()) { 71 try {file.delete();} 72 catch (SecurityException e) {} 73 } 74 } 75 _createPDataset(long fid, long dsid, String name, long dcpl_val)76 private final void _createPDataset(long fid, long dsid, String name, long dcpl_val) { 77 78 try { 79 H5dcpl_id = H5.H5Pcreate(dcpl_val); 80 } 81 catch (Exception err) { 82 err.printStackTrace(); 83 fail("H5.H5Pcreate: " + err); 84 } 85 assertTrue("testH5D._createPDataset: H5.H5Pcreate: ", H5dcpl_id >= 0); 86 87 // Set the allocation time to "early". This way we can be sure 88 // that reading from the dataset immediately after creation will 89 // return the fill value. 90 try { 91 H5.H5Pset_alloc_time(H5dcpl_id, HDF5Constants.H5D_ALLOC_TIME_EARLY); 92 } 93 catch (Exception e) { 94 e.printStackTrace(); 95 } 96 97 try { 98 H5did0 = H5.H5Dcreate(fid, name, 99 HDF5Constants.H5T_STD_I32BE, dsid, 100 HDF5Constants.H5P_DEFAULT, H5dcpl_id, HDF5Constants.H5P_DEFAULT); 101 } 102 catch (Throwable err) { 103 err.printStackTrace(); 104 fail("H5.H5Dcreate: " + err); 105 } 106 assertTrue("TestH5D._createPDataset.H5Dcreate: ", H5did0 >= 0); 107 } 108 _createChunkDataset(long fid, long dsid, String name, long dapl)109 private final void _createChunkDataset(long fid, long dsid, String name, long dapl) { 110 111 try { 112 H5dcpl_id = H5.H5Pcreate(HDF5Constants.H5P_DATASET_CREATE); 113 } 114 catch (Exception err) { 115 err.printStackTrace(); 116 fail("H5.H5Pcreate: " + err); 117 } 118 assertTrue("testH5D._createChunkDataset: H5.H5Pcreate: ", H5dcpl_id >= 0); 119 120 // Set the chunking. 121 long[] chunk_dim = {4, 4}; 122 123 try { 124 H5.H5Pset_chunk(H5dcpl_id, RANK, chunk_dim); 125 } 126 catch (Exception e) { 127 e.printStackTrace(); 128 } 129 130 try { 131 H5did = H5.H5Dcreate(fid, name, 132 HDF5Constants.H5T_STD_I32BE, dsid, 133 HDF5Constants.H5P_DEFAULT, H5dcpl_id, dapl); 134 } 135 catch (Throwable err) { 136 err.printStackTrace(); 137 fail("H5.H5Dcreate: " + err); 138 } 139 assertTrue("TestH5D._createChunkDataset.H5Dcreate: ", H5did >= 0); 140 } 141 _createDataset(long fid, long dsid, String name, long dapl)142 private final void _createDataset(long fid, long dsid, String name, long dapl) { 143 try { 144 H5did = H5.H5Dcreate(fid, name, 145 HDF5Constants.H5T_STD_I32BE, dsid, 146 HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, dapl); 147 } 148 catch (Throwable err) { 149 err.printStackTrace(); 150 fail("H5.H5Dcreate: " + err); 151 } 152 assertTrue("TestH5D._createDataset.H5Dcreate: ", H5did >= 0); 153 } 154 _createVLDataset(long fid, long dsid, String name, long dapl)155 private final void _createVLDataset(long fid, long dsid, String name, long dapl) { 156 try { 157 H5dtid = H5.H5Tcopy(HDF5Constants.H5T_C_S1); 158 } 159 catch (Throwable err) { 160 err.printStackTrace(); 161 fail("H5.H5Tcopy: " + err); 162 } 163 assertTrue("TestH5D._createVLDataset.H5Tcopy: ", H5dtid >= 0); 164 try { 165 H5.H5Tset_size(H5dtid, HDF5Constants.H5T_VARIABLE); 166 assertTrue("TestH5D._createVLDataset.H5Tis_variable_str", H5.H5Tis_variable_str(H5dtid)); 167 } 168 catch (Throwable err) { 169 err.printStackTrace(); 170 fail("H5.H5Tset_size: " + err); 171 } 172 try { 173 H5did = H5.H5Dcreate(fid, name, H5dtid, dsid, 174 HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, dapl); 175 } 176 catch (Throwable err) { 177 err.printStackTrace(); 178 fail("H5.H5Dcreate: " + err); 179 } 180 assertTrue("TestH5D._createVLDataset.H5Dcreate: ", H5did >= 0); 181 } 182 _closeH5file()183 private final void _closeH5file() throws HDF5LibraryException { 184 if (H5dcpl_id >= 0) 185 try {H5.H5Pclose(H5dcpl_id);} catch (Exception ex) {} 186 if (H5did0 >= 0) 187 try {H5.H5Dclose(H5did0);} catch (Exception ex) {} 188 if (H5did >= 0) 189 try {H5.H5Dclose(H5did);} catch (Exception ex) {} 190 if (H5dtid > 0) 191 try {H5.H5Tclose(H5dtid);} catch (Exception ex) {} 192 if (H5dsid > 0) 193 try {H5.H5Sclose(H5dsid);} catch (Exception ex) {} 194 if (H5fid > 0) 195 try {H5.H5Fclose(H5fid);} catch (Exception ex) {} 196 } 197 _openH5file(String name, long dapl)198 private final void _openH5file(String name, long dapl) { 199 try { 200 H5fid = H5.H5Fopen(H5_FILE, 201 HDF5Constants.H5F_ACC_RDWR, HDF5Constants.H5P_DEFAULT); 202 } 203 catch (Throwable err) { 204 err.printStackTrace(); 205 fail("TestH5D._openH5file: " + err); 206 } 207 assertTrue("TestH5D._openH5file: H5.H5Fopen: ",H5fid >= 0); 208 try { 209 H5did = H5.H5Dopen(H5fid, name, dapl); 210 } 211 catch (Throwable err) { 212 err.printStackTrace(); 213 fail("TestH5D._openH5file: " + err); 214 } 215 assertTrue("TestH5D._openH5file: H5.H5Dopen: ",H5did >= 0); 216 try { 217 H5dsid = H5.H5Dget_space(H5did); 218 } 219 catch (Throwable err) { 220 err.printStackTrace(); 221 fail("TestH5D._openH5file: " + err); 222 } 223 assertTrue("TestH5D._openH5file: H5.H5Screate_simple: ",H5dsid > 0); 224 } 225 226 @Before createH5file()227 public void createH5file() 228 throws NullPointerException, HDF5Exception { 229 assertTrue("H5 open ids is 0",H5.getOpenIDCount()==0); 230 System.out.print(testname.getMethodName()); 231 232 try { 233 H5faplid = H5.H5Pcreate(HDF5Constants.H5P_FILE_ACCESS); 234 H5fid = H5.H5Fcreate(H5_FILE, HDF5Constants.H5F_ACC_TRUNC, 235 HDF5Constants.H5P_DEFAULT, H5faplid); 236 H5dsid = H5.H5Screate_simple(RANK, H5dims, null); 237 } 238 catch (Throwable err) { 239 err.printStackTrace(); 240 fail("TestH5D.createH5file: " + err); 241 } 242 assertTrue("TestH5D.createH5file: H5.H5Fcreate: ",H5fid >= 0); 243 assertTrue("TestH5D.createH5file: H5.H5Screate_simple: ",H5dsid >= 0); 244 245 H5.H5Fflush(H5fid, HDF5Constants.H5F_SCOPE_LOCAL); 246 } 247 248 @After deleteH5file()249 public void deleteH5file() throws HDF5LibraryException { 250 if (H5dcpl_id >= 0) 251 try {H5.H5Pclose(H5dcpl_id);} catch (Exception ex) {} 252 if (H5did0 >= 0) 253 try {H5.H5Dclose(H5did0);} catch (Exception ex) {} 254 if (H5did >= 0) 255 try {H5.H5Dclose(H5did);} catch (Exception ex) {} 256 if (H5dtid > 0) 257 try {H5.H5Tclose(H5dtid);} catch (Exception ex) {} 258 if (H5dsid > 0) 259 try {H5.H5Sclose(H5dsid);} catch (Exception ex) {} 260 if (H5faplid >= 0) 261 try {H5.H5Pclose(H5faplid);} catch (Exception ex) {} 262 if (H5fid > 0) 263 try {H5.H5Fclose(H5fid);} catch (Exception ex) {} 264 265 _deleteFile(H5_FILE); 266 System.out.println(); 267 } 268 269 @Test testH5Dcreate()270 public void testH5Dcreate() { 271 long dataset_id = -1; 272 try { 273 dataset_id = H5.H5Dcreate(H5fid, "dset", 274 HDF5Constants.H5T_STD_I32BE, H5dsid, 275 HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); 276 } 277 catch (Exception err) { 278 err.printStackTrace(); 279 fail("testH5Dcreate: " + err); 280 } 281 assertTrue(dataset_id >= 0); 282 283 // End access to the dataset and release resources used by it. 284 try { 285 if (dataset_id >= 0) 286 H5.H5Dclose(dataset_id); 287 } 288 catch (Exception err) { 289 err.printStackTrace(); 290 } 291 } 292 293 @Test testH5Dcreate_anon()294 public void testH5Dcreate_anon() { 295 long dataset_id = -1; 296 try { 297 dataset_id = H5.H5Dcreate_anon(H5fid, HDF5Constants.H5T_STD_I32BE, 298 H5dsid, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); 299 } 300 catch (Exception err) { 301 err.printStackTrace(); 302 fail("testH5Dcreate_anon: " + err); 303 } 304 assertTrue(dataset_id >= 0); 305 306 // End access to the dataset and release resources used by it. 307 try { 308 if (dataset_id >= 0) 309 H5.H5Dclose(dataset_id); 310 } 311 catch (Exception err) { 312 err.printStackTrace(); 313 } 314 } 315 316 @Test testH5Dopen()317 public void testH5Dopen() { 318 long dataset_id = -1; 319 _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 320 321 try { 322 H5.H5Dclose(H5did); 323 H5did = -1; 324 dataset_id = H5.H5Dopen(H5fid, "dset", HDF5Constants.H5P_DEFAULT); 325 } 326 catch (Exception err) { 327 err.printStackTrace(); 328 fail("testH5Dopen: " + err); 329 } 330 assertTrue("testH5Dopen: ", dataset_id >= 0); 331 332 // End access to the dataset and release resources used by it. 333 try { 334 if (dataset_id >= 0) 335 H5.H5Dclose(dataset_id); 336 } 337 catch (Exception err) { 338 err.printStackTrace(); 339 } 340 } 341 342 @Test testH5Dget_storage_size_empty()343 public void testH5Dget_storage_size_empty() { 344 long storage_size = 0; 345 _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 346 347 try { 348 storage_size = H5.H5Dget_storage_size(H5did); 349 } 350 catch (Exception err) { 351 err.printStackTrace(); 352 fail("testH5Dget_storage_size: " + err); 353 } 354 assertTrue("testH5Dget_storage_size: ", storage_size == 0); 355 } 356 357 @Test testH5Dget_storage_size()358 public void testH5Dget_storage_size() { 359 long storage_size = 0; 360 int[][] dset_data = new int[DIM_X][DIM_Y]; 361 int FILLVAL = 99; 362 _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 363 364 // Initialize the dataset. 365 for (int indx = 0; indx < DIM_X; indx++) 366 for (int jndx = 0; jndx < DIM_Y; jndx++) 367 dset_data[indx][jndx] = FILLVAL; 368 369 try { 370 if (H5did >= 0) 371 H5.H5Dwrite(H5did, HDF5Constants.H5T_NATIVE_INT, 372 HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, 373 HDF5Constants.H5P_DEFAULT, dset_data[0]); 374 } 375 catch (Exception e) { 376 e.printStackTrace(); 377 } 378 379 try { 380 storage_size = H5.H5Dget_storage_size(H5did); 381 } 382 catch (Exception err) { 383 err.printStackTrace(); 384 fail("testH5Dget_storage_size: " + err); 385 } 386 assertTrue("testH5Dget_storage_size: "+storage_size, storage_size == DIM_X*DIM_Y*4); 387 } 388 389 @Test testH5Dget_access_plist()390 public void testH5Dget_access_plist() { 391 long dapl_id = -1; 392 long test_dapl_id = -1; 393 int[] mdc_nelmts1 = {0}; 394 int[] mdc_nelmts2 = {0}; 395 long[] rdcc_nelmts1 = {0}; 396 long[] rdcc_nelmts2 = {0}; 397 long[] rdcc_nbytes1 = {0}; 398 long[] rdcc_nbytes2 = {0}; 399 double[] rdcc_w01 = {0}; 400 double[] rdcc_w02 = {0}; 401 402 try { 403 test_dapl_id = H5.H5Pcreate(HDF5Constants.H5P_DATASET_ACCESS); 404 } 405 catch (Exception err) { 406 err.printStackTrace(); 407 fail("testH5Dget_access_plist: H5.H5Pcreate: " + err); 408 } 409 assertTrue("testH5Dget_access_plist: test_dapl_id: ", test_dapl_id >= 0); 410 411 try { 412 H5.H5Pget_cache(H5faplid, mdc_nelmts1, rdcc_nelmts1, rdcc_nbytes1, rdcc_w01); 413 } 414 catch (Exception err) { 415 err.printStackTrace(); 416 fail("testH5Dget_access_plist: H5.H5Pget_cache: " + err); 417 } 418 419 _createChunkDataset(H5fid, H5dsid, "dset", test_dapl_id); 420 421 try { 422 dapl_id = H5.H5Dget_access_plist(H5did); 423 assertTrue("testH5Dget_access_plist: dapl_id: ", dapl_id >= 0); 424 H5.H5Pget_chunk_cache(dapl_id, rdcc_nelmts2, rdcc_nbytes2, rdcc_w02); 425 } 426 catch (Exception err) { 427 err.printStackTrace(); 428 fail("testH5Dget_access_plist: H5.H5Dget_access_plist: " + err); 429 } 430 431 // End access to the dataset and release resources used by it. 432 try { 433 if (dapl_id >= 0) 434 H5.H5Pclose(dapl_id); 435 } 436 catch (Exception err) { 437 err.printStackTrace(); 438 } 439 try { 440 if (test_dapl_id >= 0) 441 H5.H5Pclose(test_dapl_id); 442 } 443 catch (Exception err) { 444 err.printStackTrace(); 445 } 446 assertTrue("testH5Dget_access_plist: ", rdcc_nelmts2==rdcc_nelmts2 && rdcc_nbytes2==rdcc_nbytes2); 447 } 448 449 @Test testH5Dget_space_status()450 public void testH5Dget_space_status() { 451 int[][] write_dset_data = new int[DIM_X][DIM_Y]; 452 int space_status = -1; 453 int space_status0 = -1; 454 455 // Initialize the dataset. 456 for (int indx = 0; indx < DIM_X; indx++) 457 for (int jndx = 0; jndx < DIM_Y; jndx++) 458 write_dset_data[indx][jndx] = indx * jndx - jndx; 459 460 _createPDataset(H5fid, H5dsid, "dset0", HDF5Constants.H5P_DATASET_CREATE); 461 _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 462 463 // Retrieve and print space status and storage size for dset0. 464 try { 465 space_status0 = H5.H5Dget_space_status(H5did0); 466 } 467 catch (Exception e) { 468 e.printStackTrace(); 469 } 470 assertTrue("testH5Dget_space_status0 - H5.H5Dget_space_status: ", space_status0 == H5D_space_status.H5D_SPACE_STATUS_ALLOCATED.getCode()); 471 472 // Retrieve and print space status and storage size for dset. 473 try { 474 space_status = H5.H5Dget_space_status(H5did); 475 } 476 catch (Exception e) { 477 e.printStackTrace(); 478 } 479 assertFalse("testH5Dget_space_status - H5.H5Dget_space_status: ", space_status == H5D_space_status.H5D_SPACE_STATUS_ALLOCATED.getCode()); 480 481 // Write the data to the dataset. 482 try { 483 H5.H5Dwrite(H5did, HDF5Constants.H5T_NATIVE_INT, 484 HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, 485 HDF5Constants.H5P_DEFAULT, write_dset_data); 486 } 487 catch (Exception e) { 488 e.printStackTrace(); 489 } 490 491 // Retrieve and print space status and storage size for dset. 492 try { 493 space_status = H5.H5Dget_space_status(H5did); 494 } 495 catch (Exception e) { 496 e.printStackTrace(); 497 } 498 assertTrue("testH5Dget_space_status - H5.H5Dget_space_status: ", space_status == H5D_space_status.H5D_SPACE_STATUS_ALLOCATED.getCode()); 499 } 500 501 @Test(expected = HDF5LibraryException.class) testH5Dget_space_closed()502 public void testH5Dget_space_closed() throws Throwable { 503 long dataset_id = -1; 504 try { 505 dataset_id = H5.H5Dcreate(H5fid, "dset", 506 HDF5Constants.H5T_STD_I32BE, H5dsid, 507 HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); 508 } 509 catch (Throwable err) { 510 err.printStackTrace(); 511 fail("H5.H5Dcreate: " + err); 512 } 513 assertTrue("TestH5D.testH5Dget_space_closed: ", dataset_id >= 0); 514 H5.H5Dclose(dataset_id); 515 516 H5.H5Dget_space(dataset_id); 517 } 518 519 @Test testH5Dget_space()520 public void testH5Dget_space() { 521 long dataspace_id = -1; 522 _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 523 524 try { 525 dataspace_id = H5.H5Dget_space(H5did); 526 } 527 catch (Exception err) { 528 err.printStackTrace(); 529 fail("H5.H5Dget_space: " + err); 530 } 531 assertTrue("TestH5D.testH5Dget_space: ", dataspace_id >= 0); 532 533 // End access to the dataspace and release resources used by it. 534 try { 535 if (dataspace_id >= 0) 536 H5.H5Sclose(dataspace_id); 537 } 538 catch (Exception err) { 539 err.printStackTrace(); 540 } 541 } 542 543 @Test(expected = HDF5LibraryException.class) testH5Dget_type_closed()544 public void testH5Dget_type_closed() throws Throwable { 545 long dataset_id = -1; 546 try { 547 dataset_id = H5.H5Dcreate(H5fid, "dset", 548 HDF5Constants.H5T_STD_I32BE, H5dsid, 549 HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); 550 } 551 catch (Throwable err) { 552 err.printStackTrace(); 553 fail("H5.H5Dcreate: " + err); 554 } 555 assertTrue("TestH5D.testH5Dget_type_closed: ", dataset_id >= 0); 556 H5.H5Dclose(dataset_id); 557 558 H5.H5Dget_type(dataset_id); 559 } 560 561 @Test testH5Dget_type()562 public void testH5Dget_type() { 563 long datatype_id = -1; 564 _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 565 566 try { 567 datatype_id = H5.H5Dget_type(H5did); 568 } 569 catch (Exception err) { 570 err.printStackTrace(); 571 fail("H5.H5Dget_type: " + err); 572 } 573 assertTrue("TestH5D.testH5Dget_type: ", datatype_id >= 0); 574 575 // End access to the datatype and release resources used by it. 576 try { 577 if (datatype_id >= 0) 578 H5.H5Tclose(datatype_id); 579 } 580 catch (Exception err) { 581 err.printStackTrace(); 582 } 583 } 584 585 @Test testH5Dget_offset()586 public void testH5Dget_offset() { 587 int[][] write_dset_data = new int[DIM_X][DIM_Y]; 588 long dset_address = 0; 589 _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 590 591 try { 592 // Test dataset address. Should be undefined. 593 dset_address = H5.H5Dget_offset(H5did); 594 } 595 catch (HDF5LibraryException hdfex) { 596 ; 597 } 598 catch (Exception err) { 599 err.printStackTrace(); 600 fail("H5.H5Dget_offset: " + err); 601 } 602 // Write the data to the dataset. 603 try { 604 H5.H5Dwrite(H5did, HDF5Constants.H5T_NATIVE_INT, 605 HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, 606 HDF5Constants.H5P_DEFAULT, write_dset_data); 607 } 608 catch (Exception e) { 609 e.printStackTrace(); 610 } 611 612 try { 613 // Test dataset address. 614 dset_address = H5.H5Dget_offset(H5did); 615 } 616 catch (Exception err) { 617 err.printStackTrace(); 618 fail("H5.H5Dget_offset: " + err); 619 } 620 621 assertTrue("TestH5D.testH5Dget_offset: ", dset_address >= 0); 622 } 623 624 @Test testH5Dfill_null()625 public void testH5Dfill_null() { 626 int[] buf_data = new int[DIM_X*DIM_Y]; 627 628 // Initialize memory buffer 629 for (int indx = 0; indx < DIM_X; indx++) 630 for (int jndx = 0; jndx < DIM_Y; jndx++) { 631 buf_data[(indx * DIM_Y) + jndx] = indx * jndx - jndx; 632 } 633 byte[] buf_array = HDFNativeData.intToByte(0, DIM_X*DIM_Y, buf_data); 634 635 // Fill selection in memory 636 try { 637 H5.H5Dfill(null, HDF5Constants.H5T_NATIVE_UINT, buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid); 638 } 639 catch (Exception err) { 640 err.printStackTrace(); 641 fail("H5.H5Dfill: " + err); 642 } 643 buf_data = HDFNativeData.byteToInt(buf_array); 644 645 // Verify memory buffer the hard way 646 for (int indx = 0; indx < DIM_X; indx++) 647 for (int jndx = 0; jndx < DIM_Y; jndx++) 648 assertTrue("H5.H5Dfill: [" + indx+","+jndx + "] ", buf_data[(indx * DIM_Y) + jndx] == 0); 649 } 650 651 @Test testH5Dfill()652 public void testH5Dfill() { 653 int[] buf_data = new int[DIM_X*DIM_Y]; 654 byte[] fill_value = HDFNativeData.intToByte(254); 655 656 // Initialize memory buffer 657 for (int indx = 0; indx < DIM_X; indx++) 658 for (int jndx = 0; jndx < DIM_Y; jndx++) { 659 buf_data[(indx * DIM_Y) + jndx] = indx * jndx - jndx; 660 } 661 byte[] buf_array = HDFNativeData.intToByte(0, DIM_X*DIM_Y, buf_data); 662 663 // Fill selection in memory 664 try { 665 H5.H5Dfill(fill_value, HDF5Constants.H5T_NATIVE_UINT, buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid); 666 } 667 catch (Exception err) { 668 err.printStackTrace(); 669 fail("H5.H5Dfill: " + err); 670 } 671 buf_data = HDFNativeData.byteToInt(buf_array); 672 673 // Verify memory buffer the hard way 674 for (int indx = 0; indx < DIM_X; indx++) 675 for (int jndx = 0; jndx < DIM_Y; jndx++) 676 assertTrue("H5.H5Dfill: [" + indx+","+jndx + "] ", buf_data[(indx * DIM_Y) + jndx] == 254); 677 } 678 679 @Test testH5Diterate()680 public void testH5Diterate() { 681 final int SPACE_RANK = 2; 682 final int SPACE_FILL = 254; 683 684 class H5D_iter_data implements H5D_iterate_t { 685 public int fill_value; /* The fill value to check */ 686 public long fill_curr_coord; /* Current coordinate to examine */ 687 public long[] fill_coords; /* Pointer to selection's coordinates */ 688 } 689 690 H5D_iterate_t iter_data = new H5D_iter_data(); 691 692 class H5D_iter_callback implements H5D_iterate_cb { 693 public int callback(byte[] elem_buf, long elem_id, int ndim, long[] point, H5D_iterate_t op_data) { 694 //Check value in current buffer location 695 int element = HDFNativeData.byteToInt(elem_buf, 0); 696 if(element != ((H5D_iter_data)op_data).fill_value) 697 return -1; 698 //Check number of dimensions 699 if(ndim != SPACE_RANK) 700 return(-1); 701 //Check Coordinates 702 long[] fill_coords = new long[2]; 703 fill_coords[0] = ((H5D_iter_data)op_data).fill_coords[(int) (2 * ((H5D_iter_data)op_data).fill_curr_coord)]; 704 fill_coords[1] = ((H5D_iter_data)op_data).fill_coords[(int) (2 * ((H5D_iter_data)op_data).fill_curr_coord) + 1]; 705 ((H5D_iter_data)op_data).fill_curr_coord++; 706 if(fill_coords[0] != point[0]) 707 return(-1); 708 if(fill_coords[1] != point[1]) 709 return(-1); 710 711 return(0); 712 } 713 } 714 715 int[] buf_data = new int[DIM_X*DIM_Y]; 716 byte[] fill_value = HDFNativeData.intToByte(SPACE_FILL); 717 718 // Initialize memory buffer 719 for (int indx = 0; indx < DIM_X; indx++) 720 for (int jndx = 0; jndx < DIM_Y; jndx++) { 721 buf_data[(indx * DIM_Y) + jndx] = indx * jndx - jndx; 722 } 723 byte[] buf_array = HDFNativeData.intToByte(0, DIM_X*DIM_Y, buf_data); 724 725 // Fill selection in memory 726 try { 727 H5.H5Dfill(fill_value, HDF5Constants.H5T_NATIVE_UINT, buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid); 728 } 729 catch (Exception err) { 730 err.printStackTrace(); 731 fail("H5.H5Diterate: " + err); 732 } 733 734 // Initialize the iterator structure 735 ((H5D_iter_data)iter_data).fill_value = SPACE_FILL; 736 ((H5D_iter_data)iter_data).fill_curr_coord = 0; 737 // Set the coordinates of the selection 738 ((H5D_iter_data)iter_data).fill_coords = new long[DIM_X*DIM_Y*SPACE_RANK]; /* Coordinates of selection */ 739 for (int indx = 0; indx < DIM_X; indx++) 740 for (int jndx = 0; jndx < DIM_Y; jndx++) { 741 ((H5D_iter_data)iter_data).fill_coords[2*(indx * DIM_Y + jndx)] = indx; 742 ((H5D_iter_data)iter_data).fill_coords[2*(indx * DIM_Y + jndx) + 1] = jndx; 743 } /* end for */ 744 745 // Iterate through selection, verifying correct data 746 H5D_iterate_cb iter_cb = new H5D_iter_callback(); 747 int op_status = -1; 748 try { 749 op_status = H5.H5Diterate(buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid, iter_cb, iter_data); 750 } 751 catch (Throwable err) { 752 err.printStackTrace(); 753 fail("H5.H5Diterate: " + err); 754 } 755 assertTrue("H5Diterate ", op_status == 0); 756 } 757 758 @Test testH5Diterate_write()759 public void testH5Diterate_write() { 760 final int SPACE_RANK = 2; 761 final int SPACE_FILL = 254; 762 763 class H5D_iter_data implements H5D_iterate_t { 764 public int fill_value; /* The fill value to check */ 765 public long fill_curr_coord; /* Current coordinate to examine */ 766 public long[] fill_coords; /* Pointer to selection's coordinates */ 767 } 768 769 H5D_iterate_t iter_data = new H5D_iter_data(); 770 771 class H5D_iter_callback implements H5D_iterate_cb { 772 public int callback(byte[] elem_buf, long elem_id, int ndim, long[] point, H5D_iterate_t op_data) { 773 //Check value in current buffer location 774 int element = HDFNativeData.byteToInt(elem_buf, 0); 775 if(element != ((H5D_iter_data)op_data).fill_value) 776 return -1; 777 //Check number of dimensions 778 if(ndim != SPACE_RANK) 779 return(-1); 780 //Check Coordinates 781 long[] fill_coords = new long[2]; 782 fill_coords[0] = ((H5D_iter_data)op_data).fill_coords[(int) (2 * ((H5D_iter_data)op_data).fill_curr_coord)]; 783 fill_coords[1] = ((H5D_iter_data)op_data).fill_coords[(int) (2 * ((H5D_iter_data)op_data).fill_curr_coord) + 1]; 784 ((H5D_iter_data)op_data).fill_curr_coord++; 785 if(fill_coords[0] != point[0]) 786 return(-1); 787 if(fill_coords[1] != point[1]) 788 return(-1); 789 element -= 128; 790 byte[] new_elembuf = HDFNativeData.intToByte(element); 791 elem_buf[0] = new_elembuf[0]; 792 elem_buf[1] = new_elembuf[1]; 793 elem_buf[2] = new_elembuf[2]; 794 elem_buf[3] = new_elembuf[3]; 795 return(0); 796 } 797 } 798 799 int[] buf_data = new int[DIM_X*DIM_Y]; 800 byte[] fill_value = HDFNativeData.intToByte(SPACE_FILL); 801 802 // Initialize memory buffer 803 for (int indx = 0; indx < DIM_X; indx++) 804 for (int jndx = 0; jndx < DIM_Y; jndx++) { 805 buf_data[(indx * DIM_Y) + jndx] = indx * jndx - jndx; 806 } 807 byte[] buf_array = HDFNativeData.intToByte(0, DIM_X*DIM_Y, buf_data); 808 809 // Fill selection in memory 810 try { 811 H5.H5Dfill(fill_value, HDF5Constants.H5T_NATIVE_UINT, buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid); 812 } 813 catch (Exception err) { 814 err.printStackTrace(); 815 fail("H5.H5Diterate: " + err); 816 } 817 818 // Initialize the iterator structure 819 ((H5D_iter_data)iter_data).fill_value = SPACE_FILL; 820 ((H5D_iter_data)iter_data).fill_curr_coord = 0; 821 // Set the coordinates of the selection 822 ((H5D_iter_data)iter_data).fill_coords = new long[DIM_X*DIM_Y*SPACE_RANK]; /* Coordinates of selection */ 823 for (int indx = 0; indx < DIM_X; indx++) 824 for (int jndx = 0; jndx < DIM_Y; jndx++) { 825 ((H5D_iter_data)iter_data).fill_coords[2*(indx * DIM_Y + jndx)] = indx; 826 ((H5D_iter_data)iter_data).fill_coords[2*(indx * DIM_Y + jndx) + 1] = jndx; 827 } /* end for */ 828 829 // Iterate through selection, verifying correct data 830 H5D_iterate_cb iter_cb = new H5D_iter_callback(); 831 int op_status = -1; 832 try { 833 op_status = H5.H5Diterate(buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid, iter_cb, iter_data); 834 } 835 catch (Throwable err) { 836 err.printStackTrace(); 837 fail("H5.H5Diterate: " + err); 838 } 839 assertTrue("H5Diterate ", op_status == 0); 840 841 buf_data = HDFNativeData.byteToInt(buf_array); 842 843 // Verify memory buffer the hard way 844 for (int indx = 0; indx < DIM_X; indx++) 845 for (int jndx = 0; jndx < DIM_Y; jndx++) 846 assertTrue("H5.H5Diterate: [" + indx+","+jndx + "] "+buf_data[(indx * DIM_Y) + jndx], buf_data[(indx * DIM_Y) + jndx] == 126); 847 } 848 849 @Test testH5Dvlen_get_buf_size()850 public void testH5Dvlen_get_buf_size() { 851 String[] str_data = { "Parting", "is such", "sweet", "sorrow.", 852 "Testing", "one", "two", "three.", 853 "Dog,", "man's", "best", "friend.", 854 "Diamonds", "are", "a", "girls!", 855 "S A", "T U R", "D A Y", "night", 856 "That's", "all", "folks", "!!!" }; 857 long vl_size = -1; /* Number of bytes used */ 858 long str_data_bytes = 0; 859 for (int idx = 0; idx < str_data.length; idx++) 860 str_data_bytes += str_data[idx].length() + 1; //Account for terminating null 861 862 _createVLDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 863 864 try { 865 if ((H5did >= 0) && (H5dtid >= 0)) 866 H5.H5Dwrite_VLStrings(H5did, H5dtid, 867 HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, 868 HDF5Constants.H5P_DEFAULT, str_data); 869 } 870 catch (Exception e) { 871 e.printStackTrace(); 872 } 873 try { 874 vl_size = H5.H5Dvlen_get_buf_size(H5did, H5dtid, H5dsid); 875 } 876 catch (Exception e) { 877 e.printStackTrace(); 878 } 879 assertTrue("H5Dvlen_get_buf_size " + vl_size + " == " + str_data_bytes, vl_size == str_data_bytes); 880 } 881 882 @Test(expected = IllegalArgumentException.class) testH5Dvlen_read_invalid_buffer()883 public void testH5Dvlen_read_invalid_buffer() throws Throwable { 884 String[] str_data = { "Parting", "is such", "sweet", "sorrow.", 885 "Testing", "one", "two", "three.", 886 "Dog,", "man's", "best", "friend.", 887 "Diamonds", "are", "a", "girls!", 888 "S A", "T U R", "D A Y", "night", 889 "That's", "all", "folks", "!!!" }; 890 byte[] read_data = new byte[512]; 891 892 _createVLDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 893 894 try { 895 H5.H5Dwrite_VLStrings(H5did, H5dtid, 896 HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, 897 HDF5Constants.H5P_DEFAULT, str_data); 898 } 899 catch (Exception e) { 900 e.printStackTrace(); 901 } 902 903 H5.H5Dread(H5did, H5dtid, 904 HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, 905 HDF5Constants.H5P_DEFAULT, read_data); 906 } 907 908 @Test testH5Dvlen_write_read()909 public void testH5Dvlen_write_read() { 910 String[] str_wdata = { "Parting", "is such", "sweet", "sorrow.", 911 "Testing", "one", "two", "three.", 912 "Dog,", "man's", "best", "friend.", 913 "Diamonds", "are", "a", "girls!", 914 "S A", "T U R", "D A Y", "night", 915 "That's", "all", "folks", "!!!" }; 916 String[] str_rdata = new String[DIM_X * DIM_Y]; 917 918 _createVLDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); 919 920 try { 921 if ((H5did >= 0) && (H5dtid >= 0)) 922 H5.H5Dwrite_VLStrings(H5did, H5dtid, 923 HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, 924 HDF5Constants.H5P_DEFAULT, str_wdata); 925 } 926 catch (Exception e) { 927 e.printStackTrace(); 928 } 929 try { 930 if ((H5did >= 0) && (H5dtid >= 0)) 931 H5.H5Dread_VLStrings(H5did, H5dtid, 932 HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, 933 HDF5Constants.H5P_DEFAULT, str_rdata); 934 } 935 catch (Exception e) { 936 e.printStackTrace(); 937 } 938 for (int v = 0; v < DIM_X * DIM_Y; v++) 939 assertTrue("testH5Dvlen_write_read " + str_wdata[v] + " == " + str_rdata[v], str_wdata[v] == str_wdata[v]); 940 } 941 942 } 943