/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Copyright by The HDF Group. * * All rights reserved. * * * * This file is part of HDF5. The full HDF5 copyright notice, including * * terms governing use, modification, and redistribution, is contained in * * the LICENSE file, which can be found at the root of the source code * * distribution tree, or in https://www.hdfgroup.org/licenses. * * If you do not have access to either file, you may request a copy from * * help@hdfgroup.org. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ package test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import java.io.File; import java.lang.Integer; import java.lang.foreign.MemoryLayout; import java.lang.foreign.MemoryLayout.PathElement; import java.lang.foreign.MemorySegment; import java.lang.foreign.SequenceLayout; import java.lang.foreign.ValueLayout; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import hdf.hdf5lib.H5; import hdf.hdf5lib.HDF5Constants; import hdf.hdf5lib.HDFArray; import hdf.hdf5lib.callbacks.H5D_iterate_cb; import hdf.hdf5lib.callbacks.H5D_iterate_t; import hdf.hdf5lib.exceptions.HDF5Exception; import hdf.hdf5lib.exceptions.HDF5LibraryException; import org.junit.After; import org.junit.Before; import org.junit.Ignore; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TestName; public class TestH5D { @Rule public TestName testname = new TestName(); private static final String H5_FILE = "testD.h5"; private static final int DIM_X = 4; private static final int DIM_Y = 6; private static final int RANK = 2; long H5fid = HDF5Constants.H5I_INVALID_HID; long H5faplid = HDF5Constants.H5I_INVALID_HID; long H5dsid = HDF5Constants.H5I_INVALID_HID; long H5dtid = HDF5Constants.H5I_INVALID_HID; long H5did = HDF5Constants.H5I_INVALID_HID; long H5did0 = HDF5Constants.H5I_INVALID_HID; long H5dcpl_id = HDF5Constants.H5I_INVALID_HID; long[] H5dims = {DIM_X, DIM_Y}; // Values for the status of space allocation enum H5D_space_status { H5D_SPACE_STATUS_ERROR(-1), H5D_SPACE_STATUS_NOT_ALLOCATED(0), H5D_SPACE_STATUS_PART_ALLOCATED(1), H5D_SPACE_STATUS_ALLOCATED(2); private int code; H5D_space_status(int space_status) { this.code = space_status; } public int getCode() { return this.code; } } // Helper class for compound datatype testing static class TestSensor { static final int MAXSTRINGSIZE = 32; static final int INTEGERSIZE = 4; static final int DOUBLESIZE = 8; public int serial_no; public String location; public double temperature; public double pressure; TestSensor(int serial_no, String location, double temperature, double pressure) { this.serial_no = serial_no; this.location = location; this.temperature = temperature; this.pressure = pressure; } TestSensor(ArrayList data) { this.serial_no = (Integer)data.get(0); this.location = (String)data.get(1); this.temperature = (Double)data.get(2); this.pressure = (Double)data.get(3); } ArrayList toArrayList() { ArrayList data = new ArrayList(); data.add(serial_no); data.add(location); data.add(temperature); data.add(pressure); return data; } static long createMemType() throws HDF5Exception { long strtype_id = HDF5Constants.H5I_INVALID_HID; long memtype_id = HDF5Constants.H5I_INVALID_HID; try { strtype_id = H5.H5Tcopy(HDF5Constants.H5T_C_S1); H5.H5Tset_size(strtype_id, MAXSTRINGSIZE); memtype_id = H5.H5Tcreate(HDF5Constants.H5T_COMPOUND, INTEGERSIZE + MAXSTRINGSIZE + DOUBLESIZE + DOUBLESIZE); H5.H5Tinsert(memtype_id, "Serial number", 0, HDF5Constants.H5T_NATIVE_INT); H5.H5Tinsert(memtype_id, "Location", INTEGERSIZE, strtype_id); H5.H5Tinsert(memtype_id, "Temperature", INTEGERSIZE + MAXSTRINGSIZE, HDF5Constants.H5T_NATIVE_DOUBLE); H5.H5Tinsert(memtype_id, "Pressure", INTEGERSIZE + MAXSTRINGSIZE + DOUBLESIZE, HDF5Constants.H5T_NATIVE_DOUBLE); H5.H5Tclose(strtype_id); } catch (Exception e) { if (strtype_id >= 0) H5.H5Tclose(strtype_id); if (memtype_id >= 0) H5.H5Tclose(memtype_id); throw e; } return memtype_id; } } private final void _deleteFile(String filename) { File file = new File(filename); if (file.exists()) { try { file.delete(); } catch (SecurityException e) { } } } private final void _createPDataset(long fid, long dsid, String name, long dcpl_val) { try { H5dcpl_id = H5.H5Pcreate(dcpl_val); } catch (Exception err) { err.printStackTrace(); fail("H5.H5Pcreate: " + err); } assertTrue("testH5D._createPDataset: H5.H5Pcreate: ", H5dcpl_id >= 0); // Set the allocation time to "early". This way we can be sure // that reading from the dataset immediately after creation will // return the fill value. try { H5.H5Pset_alloc_time(H5dcpl_id, HDF5Constants.H5D_ALLOC_TIME_EARLY); } catch (Exception e) { e.printStackTrace(); } try { H5did0 = H5.H5Dcreate(fid, name, HDF5Constants.H5T_STD_I32BE, dsid, HDF5Constants.H5P_DEFAULT, H5dcpl_id, HDF5Constants.H5P_DEFAULT); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Dcreate: " + err); } assertTrue("TestH5D._createPDataset.H5Dcreate: ", H5did0 >= 0); } private final void _createChunkDataset(long fid, long dsid, String name, long dapl) { try { H5dcpl_id = H5.H5Pcreate(HDF5Constants.H5P_DATASET_CREATE); } catch (Exception err) { err.printStackTrace(); fail("H5.H5Pcreate: " + err); } assertTrue("testH5D._createChunkDataset: H5.H5Pcreate: ", H5dcpl_id >= 0); // Set the chunking. long[] chunk_dim = {4, 4}; try { H5.H5Pset_chunk(H5dcpl_id, RANK, chunk_dim); } catch (Exception e) { e.printStackTrace(); } try { H5did = H5.H5Dcreate(fid, name, HDF5Constants.H5T_STD_I32BE, dsid, HDF5Constants.H5P_DEFAULT, H5dcpl_id, dapl); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Dcreate: " + err); } assertTrue("TestH5D._createChunkDataset.H5Dcreate: ", H5did >= 0); } private final void _createDataset(long fid, long dsid, String name, long dapl) { try { H5did = H5.H5Dcreate(fid, name, HDF5Constants.H5T_STD_I32BE, dsid, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, dapl); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Dcreate: " + err); } assertTrue("TestH5D._createDataset.H5Dcreate: ", H5did >= 0); } private final void _createVLStrDataset(String name, long dapl) { try { H5dtid = H5.H5Tcopy(HDF5Constants.H5T_C_S1); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Tcopy: " + err); } assertTrue("TestH5D._createVLStrDataset.H5Tcopy: ", H5dtid >= 0); try { H5.H5Tset_size(H5dtid, HDF5Constants.H5T_VARIABLE); assertTrue("TestH5D._createVLStrDataset.H5Tis_variable_str", H5.H5Tis_variable_str(H5dtid)); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Tset_size: " + err); } try { H5did = H5.H5Dcreate(H5fid, name, H5dtid, H5dsid, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, dapl); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Dcreate: " + err); } assertTrue("TestH5D._createVLStrDataset.H5Dcreate: ", H5did >= 0); } private final void _closeH5file() throws HDF5LibraryException { if (H5dcpl_id >= 0) try { H5.H5Pclose(H5dcpl_id); } catch (Exception ex) { } if (H5did0 >= 0) try { H5.H5Dclose(H5did0); } catch (Exception ex) { } if (H5did >= 0) try { H5.H5Dclose(H5did); } catch (Exception ex) { } if (H5dtid > 0) try { H5.H5Tclose(H5dtid); } catch (Exception ex) { } if (H5dsid > 0) try { H5.H5Sclose(H5dsid); } catch (Exception ex) { } if (H5fid > 0) try { H5.H5Fclose(H5fid); } catch (Exception ex) { } } private final void _openH5file(String filename, String dsetname, long dapl) { try { H5fid = H5.H5Fopen(filename, HDF5Constants.H5F_ACC_RDONLY, HDF5Constants.H5P_DEFAULT); } catch (Throwable err) { err.printStackTrace(); fail("TestH5D._openH5file: " + err); } assertTrue("TestH5D._openH5file: H5.H5Fopen: ", H5fid >= 0); try { H5did = H5.H5Dopen(H5fid, dsetname, dapl); } catch (Throwable err) { err.printStackTrace(); fail("TestH5D._openH5file: " + err); } assertTrue("TestH5D._openH5file: H5.H5Dopen: ", H5did >= 0); try { H5dsid = H5.H5Dget_space(H5did); } catch (Throwable err) { err.printStackTrace(); fail("TestH5D._openH5file: " + err); } assertTrue("TestH5D._openH5file: H5.H5Screate_simple: ", H5dsid > 0); } @Before public void createH5file() throws NullPointerException, HDF5Exception { assertTrue("H5 open ids is 0", H5.getOpenIDCount() == 0); System.out.print(testname.getMethodName()); try { H5faplid = H5.H5Pcreate(HDF5Constants.H5P_FILE_ACCESS); H5fid = H5.H5Fcreate(H5_FILE, HDF5Constants.H5F_ACC_TRUNC, HDF5Constants.H5P_DEFAULT, H5faplid); H5dsid = H5.H5Screate_simple(RANK, H5dims, null); } catch (Throwable err) { err.printStackTrace(); fail("TestH5D.createH5file: " + err); } assertTrue("TestH5D.createH5file: H5.H5Fcreate: ", H5fid >= 0); assertTrue("TestH5D.createH5file: H5.H5Screate_simple: ", H5dsid >= 0); H5.H5Fflush(H5fid, HDF5Constants.H5F_SCOPE_LOCAL); } @After public void deleteH5file() throws HDF5LibraryException { if (H5dcpl_id >= 0) try { H5.H5Pclose(H5dcpl_id); } catch (Exception ex) { } if (H5did0 >= 0) try { H5.H5Dclose(H5did0); } catch (Exception ex) { } if (H5did >= 0) try { H5.H5Dclose(H5did); } catch (Exception ex) { } if (H5dtid > 0) try { H5.H5Tclose(H5dtid); } catch (Exception ex) { } if (H5dsid > 0) try { H5.H5Sclose(H5dsid); } catch (Exception ex) { } if (H5faplid >= 0) try { H5.H5Pclose(H5faplid); } catch (Exception ex) { } if (H5fid > 0) try { H5.H5Fclose(H5fid); } catch (Exception ex) { } _deleteFile(H5_FILE); System.out.println(); } @Test public void testH5Dcreate() { long dataset_id = HDF5Constants.H5I_INVALID_HID; try { dataset_id = H5.H5Dcreate(H5fid, "dset", HDF5Constants.H5T_STD_I32BE, H5dsid, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); } catch (Exception err) { err.printStackTrace(); fail("testH5Dcreate: " + err); } assertTrue(dataset_id >= 0); // End access to the dataset and release resources used by it. try { if (dataset_id >= 0) H5.H5Dclose(dataset_id); } catch (Exception err) { err.printStackTrace(); } } @Test public void testH5Dcreate_anon() { long dataset_id = HDF5Constants.H5I_INVALID_HID; try { dataset_id = H5.H5Dcreate_anon(H5fid, HDF5Constants.H5T_STD_I32BE, H5dsid, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); } catch (Exception err) { err.printStackTrace(); fail("testH5Dcreate_anon: " + err); } assertTrue(dataset_id >= 0); // End access to the dataset and release resources used by it. try { if (dataset_id >= 0) H5.H5Dclose(dataset_id); } catch (Exception err) { err.printStackTrace(); } } @Test public void testH5Dopen() { long dataset_id = HDF5Constants.H5I_INVALID_HID; _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); try { H5.H5Dclose(H5did); H5did = HDF5Constants.H5I_INVALID_HID; dataset_id = H5.H5Dopen(H5fid, "dset", HDF5Constants.H5P_DEFAULT); } catch (Exception err) { err.printStackTrace(); fail("testH5Dopen: " + err); } assertTrue("testH5Dopen: ", dataset_id >= 0); // End access to the dataset and release resources used by it. try { if (dataset_id >= 0) H5.H5Dclose(dataset_id); } catch (Exception err) { err.printStackTrace(); } } @Test public void testH5Dget_storage_size_empty() { long storage_size = 0; _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); try { storage_size = H5.H5Dget_storage_size(H5did); } catch (Exception err) { err.printStackTrace(); fail("testH5Dget_storage_size: " + err); } assertTrue("testH5Dget_storage_size: ", storage_size == 0); } @Test public void testH5Dget_storage_size() { long storage_size = 0; int[][] dset_data = new int[DIM_X][DIM_Y]; int FILLVAL = 99; _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); // Initialize the dataset. for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) dset_data[indx][jndx] = FILLVAL; try { if (H5did >= 0) H5.H5Dwrite(H5did, HDF5Constants.H5T_NATIVE_INT, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, dset_data[0]); } catch (Exception e) { e.printStackTrace(); } try { storage_size = H5.H5Dget_storage_size(H5did); } catch (Exception err) { err.printStackTrace(); fail("testH5Dget_storage_size: " + err); } assertTrue("testH5Dget_storage_size: " + storage_size, storage_size == DIM_X * DIM_Y * 4); } @Test public void testH5Dget_access_plist() { long dapl_id = HDF5Constants.H5I_INVALID_HID; long test_dapl_id = HDF5Constants.H5I_INVALID_HID; int[] mdc_nelmts1 = {0}; int[] mdc_nelmts2 = {0}; long[] rdcc_nelmts1 = {0}; long[] rdcc_nelmts2 = {0}; long[] rdcc_nbytes1 = {0}; long[] rdcc_nbytes2 = {0}; double[] rdcc_w01 = {0}; double[] rdcc_w02 = {0}; try { test_dapl_id = H5.H5Pcreate(HDF5Constants.H5P_DATASET_ACCESS); } catch (Exception err) { err.printStackTrace(); fail("testH5Dget_access_plist: H5.H5Pcreate: " + err); } assertTrue("testH5Dget_access_plist: test_dapl_id: ", test_dapl_id >= 0); try { H5.H5Pget_cache(H5faplid, mdc_nelmts1, rdcc_nelmts1, rdcc_nbytes1, rdcc_w01); } catch (Exception err) { err.printStackTrace(); fail("testH5Dget_access_plist: H5.H5Pget_cache: " + err); } _createChunkDataset(H5fid, H5dsid, "dset", test_dapl_id); try { dapl_id = H5.H5Dget_access_plist(H5did); assertTrue("testH5Dget_access_plist: dapl_id: ", dapl_id >= 0); H5.H5Pget_chunk_cache(dapl_id, rdcc_nelmts2, rdcc_nbytes2, rdcc_w02); } catch (Exception err) { err.printStackTrace(); fail("testH5Dget_access_plist: H5.H5Dget_access_plist: " + err); } // End access to the dataset and release resources used by it. try { if (dapl_id >= 0) H5.H5Pclose(dapl_id); } catch (Exception err) { err.printStackTrace(); } try { if (test_dapl_id >= 0) H5.H5Pclose(test_dapl_id); } catch (Exception err) { err.printStackTrace(); } assertTrue("testH5Dget_access_plist: ", rdcc_nelmts2 == rdcc_nelmts2 && rdcc_nbytes2 == rdcc_nbytes2); } @Test public void testH5Dget_space_status() { int[][] write_dset_data = new int[DIM_X][DIM_Y]; int space_status = -1; int space_status0 = -1; // Initialize the dataset. for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) write_dset_data[indx][jndx] = indx * jndx - jndx; _createPDataset(H5fid, H5dsid, "dset0", HDF5Constants.H5P_DATASET_CREATE); _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); // Retrieve and print space status and storage size for dset0. try { space_status0 = H5.H5Dget_space_status(H5did0); } catch (Exception e) { e.printStackTrace(); } assertTrue("testH5Dget_space_status0 - H5.H5Dget_space_status: ", space_status0 == H5D_space_status.H5D_SPACE_STATUS_ALLOCATED.getCode()); // Retrieve and print space status and storage size for dset. try { space_status = H5.H5Dget_space_status(H5did); } catch (Exception e) { e.printStackTrace(); } assertFalse("testH5Dget_space_status - H5.H5Dget_space_status: ", space_status == H5D_space_status.H5D_SPACE_STATUS_ALLOCATED.getCode()); // Write the data to the dataset. try { H5.H5Dwrite(H5did, HDF5Constants.H5T_NATIVE_INT, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, write_dset_data); } catch (Exception e) { e.printStackTrace(); } // Retrieve and print space status and storage size for dset. try { space_status = H5.H5Dget_space_status(H5did); } catch (Exception e) { e.printStackTrace(); } assertTrue("testH5Dget_space_status - H5.H5Dget_space_status: ", space_status == H5D_space_status.H5D_SPACE_STATUS_ALLOCATED.getCode()); } @Test(expected = HDF5LibraryException.class) public void testH5Dget_space_closed() throws Throwable { long dataset_id = HDF5Constants.H5I_INVALID_HID; try { dataset_id = H5.H5Dcreate(H5fid, "dset", HDF5Constants.H5T_STD_I32BE, H5dsid, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Dcreate: " + err); } assertTrue("TestH5D.testH5Dget_space_closed: ", dataset_id >= 0); H5.H5Dclose(dataset_id); H5.H5Dget_space(dataset_id); } @Test public void testH5Dget_space() { long dataspace_id = HDF5Constants.H5I_INVALID_HID; _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); try { dataspace_id = H5.H5Dget_space(H5did); } catch (Exception err) { err.printStackTrace(); fail("H5.H5Dget_space: " + err); } assertTrue("TestH5D.testH5Dget_space: ", dataspace_id >= 0); // End access to the dataspace and release resources used by it. try { if (dataspace_id >= 0) H5.H5Sclose(dataspace_id); } catch (Exception err) { err.printStackTrace(); } } @Test(expected = HDF5LibraryException.class) public void testH5Dget_type_closed() throws Throwable { long dataset_id = HDF5Constants.H5I_INVALID_HID; try { dataset_id = H5.H5Dcreate(H5fid, "dset", HDF5Constants.H5T_STD_I32BE, H5dsid, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Dcreate: " + err); } assertTrue("TestH5D.testH5Dget_type_closed: ", dataset_id >= 0); H5.H5Dclose(dataset_id); H5.H5Dget_type(dataset_id); } @Test public void testH5Dget_type() { long datatype_id = HDF5Constants.H5I_INVALID_HID; _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); try { datatype_id = H5.H5Dget_type(H5did); } catch (Exception err) { err.printStackTrace(); fail("H5.H5Dget_type: " + err); } assertTrue("TestH5D.testH5Dget_type: ", datatype_id >= 0); // End access to the datatype and release resources used by it. try { if (datatype_id >= 0) H5.H5Tclose(datatype_id); } catch (Exception err) { err.printStackTrace(); } } @Test public void testH5Dget_offset() { int[][] write_dset_data = new int[DIM_X][DIM_Y]; long dset_address = 0; _createDataset(H5fid, H5dsid, "dset", HDF5Constants.H5P_DEFAULT); try { // Test dataset address. Should be undefined. dset_address = H5.H5Dget_offset(H5did); } catch (HDF5LibraryException hdfex) { ; } catch (Exception err) { err.printStackTrace(); fail("H5.H5Dget_offset: " + err); } // Write the data to the dataset. try { H5.H5Dwrite(H5did, HDF5Constants.H5T_NATIVE_INT, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, write_dset_data); } catch (Exception e) { e.printStackTrace(); } try { // Test dataset address. dset_address = H5.H5Dget_offset(H5did); } catch (Exception err) { err.printStackTrace(); fail("H5.H5Dget_offset: " + err); } assertTrue("TestH5D.testH5Dget_offset: ", dset_address >= 0); } @Test public void testH5Dfill_null() { Integer[] buf_data = new Integer[DIM_X * DIM_Y]; // Initialize memory buffer for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) { buf_data[(indx * DIM_Y) + jndx] = Integer.valueOf(indx * jndx - jndx); } byte[] buf_array = HDFArray.IntegerToByte(buf_data); // Fill selection in memory try { H5.H5Dfill(null, HDF5Constants.H5T_NATIVE_UINT, buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid); } catch (Exception err) { err.printStackTrace(); fail("H5.H5Dfill: " + err); } buf_data = HDFArray.ByteToInteger(buf_array); // Verify memory buffer the hard way for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) assertTrue("H5.H5Dfill: [" + indx + "," + jndx + "] ", buf_data[(indx * DIM_Y) + jndx].compareTo(0) == 0); } @Test public void testH5Dfill() { Integer[] buf_data = new Integer[DIM_X * DIM_Y]; byte[] fill_value = HDFArray.intToBytes(254); // Initialize memory buffer for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) { buf_data[(indx * DIM_Y) + jndx] = Integer.valueOf(indx * jndx - jndx); } byte[] buf_array = HDFArray.IntegerToByte(buf_data); // Fill selection in memory try { H5.H5Dfill(fill_value, HDF5Constants.H5T_NATIVE_UINT, buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid); } catch (Exception err) { err.printStackTrace(); fail("H5.H5Dfill: " + err); } buf_data = HDFArray.ByteToInteger(buf_array); // Verify memory buffer the hard way for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) assertTrue("H5.H5Dfill: [" + indx + "," + jndx + "] ", buf_data[(indx * DIM_Y) + jndx].compareTo(254) == 0); } @Ignore public void testH5Diterate() { final int SPACE_RANK = 2; final int SPACE_FILL = 254; MemoryLayout ITER_LAYOUT = MemoryLayout.structLayout( MemoryLayout.sequenceLayout(SPACE_RANK, ValueLayout.JAVA_LONG).withName("fill_coords"), ValueLayout.JAVA_LONG.withName("fill_curr_coord"), ValueLayout.JAVA_INT.withName("fill_value")); VarHandle coordsHandle = ITER_LAYOUT.arrayElementVarHandle(PathElement.groupElement("fill_coords"), PathElement.sequenceElement()); VarHandle curr_coordHandle = ITER_LAYOUT.varHandle(PathElement.groupElement("fill_curr_coord")); VarHandle valueHandle = ITER_LAYOUT.varHandle(PathElement.groupElement("fill_value")); class H5D_iter_data implements H5D_iterate_t { public long[] fill_coords; /* Pointer to selection's coordinates */ public long fill_curr_coord; /* Current coordinate to examine */ public int fill_value; /* The fill value to check */ } H5D_iterate_t iter_data = new H5D_iter_data(); class H5D_iter_callback implements H5D_iterate_cb { public int apply(MemorySegment elem, long type_id, int ndim, MemorySegment point, MemorySegment operator_data) { // Check value in current buffer location int element = elem.get(ValueLayout.JAVA_INT, 0); // System.out.println("element = " + element + " fill_value = " + // (int)valueHandle.get(operator_data, 0)); if (element != (int)valueHandle.get(operator_data, 0)) return -1; // Check number of dimensions if (ndim != SPACE_RANK) return (-1); // Check Coordinates long[] fill_coords = new long[ndim]; long fill_curr_coord = (long)curr_coordHandle.get(operator_data, 0); System.out.println("fill_curr_coord = " + fill_curr_coord); for (int i = 0; i < ndim; i++) fill_coords[i] = (long)coordsHandle.get(operator_data, 0L, 2 * fill_curr_coord + i); fill_curr_coord++; curr_coordHandle.set(operator_data, 0, fill_curr_coord); for (int i = 0; i < ndim; i++) if (fill_coords[i] != point.get(ValueLayout.JAVA_LONG, i)) return (-1); return (0); } } Integer[] buf_data = new Integer[DIM_X * DIM_Y]; byte[] fill_value = HDFArray.intToBytes(SPACE_FILL); // Initialize memory buffer for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) { buf_data[(indx * DIM_Y) + jndx] = Integer.valueOf(indx * jndx - jndx); } byte[] buf_array = HDFArray.IntegerToByte(buf_data); // Fill selection in memory try { H5.H5Dfill(fill_value, HDF5Constants.H5T_NATIVE_UINT, buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid); } catch (Exception err) { err.printStackTrace(); fail("H5.H5Diterate: " + err); } // Initialize the iterator structure ((H5D_iter_data)iter_data).fill_value = SPACE_FILL; ((H5D_iter_data)iter_data).fill_curr_coord = 0; // Set the coordinates of the selection ((H5D_iter_data)iter_data).fill_coords = new long[DIM_X * DIM_Y * SPACE_RANK]; /* Coordinates of selection */ for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) { ((H5D_iter_data)iter_data).fill_coords[2 * (indx * DIM_Y + jndx)] = indx; ((H5D_iter_data)iter_data).fill_coords[2 * (indx * DIM_Y + jndx) + 1] = jndx; } /* end for */ // Iterate through selection, verifying correct data H5D_iterate_cb iter_cb = new H5D_iter_callback(); int op_status = -1; try { op_status = H5.H5Diterate(buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid, iter_cb, iter_data); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Diterate: " + err); } assertTrue("H5Diterate ", op_status == 0); } @Ignore public void testH5Diterate_write() { final int SPACE_RANK = 2; final int SPACE_FILL = 254; MemoryLayout ITER_LAYOUT = MemoryLayout.structLayout( MemoryLayout.sequenceLayout(SPACE_RANK, ValueLayout.JAVA_LONG).withName("fill_coords"), ValueLayout.JAVA_LONG.withName("fill_curr_coord"), ValueLayout.JAVA_INT.withName("fill_value")); VarHandle coordsHandle = ITER_LAYOUT.arrayElementVarHandle(PathElement.groupElement("fill_coords"), PathElement.sequenceElement()); VarHandle curr_coordHandle = ITER_LAYOUT.varHandle(PathElement.groupElement("fill_curr_coord")); VarHandle valueHandle = ITER_LAYOUT.varHandle(PathElement.groupElement("fill_value")); class H5D_iter_data implements H5D_iterate_t { public long[] fill_coords; /* Pointer to selection's coordinates */ public long fill_curr_coord; /* Current coordinate to examine */ public int fill_value; /* The fill value to check */ } H5D_iterate_t iter_data = new H5D_iter_data(); class H5D_iter_callback implements H5D_iterate_cb { public int apply(MemorySegment elem, long type_id, int ndim, MemorySegment point, MemorySegment operator_data) { // Check value in current buffer location int element = elem.get(ValueLayout.JAVA_INT, 0); if (element != (int)valueHandle.get(operator_data, 0)) return -1; // Check number of dimensions if (ndim != SPACE_RANK) return (-1); // Check Coordinates long[] fill_coords = new long[ndim]; long fill_curr_coord = (long)curr_coordHandle.get(operator_data, 0); for (int i = 0; i < ndim; i++) fill_coords[i] = (long)coordsHandle.get(operator_data, 0L, 2 * fill_curr_coord + i); fill_curr_coord++; curr_coordHandle.set(operator_data, 0, fill_curr_coord); for (int i = 0; i < ndim; i++) if (fill_coords[i] != point.get(ValueLayout.JAVA_LONG, i)) return (-1); element -= 128; elem.set(ValueLayout.JAVA_LONG, 0, element); return (0); } } Integer[] buf_data = new Integer[DIM_X * DIM_Y]; byte[] fill_value = new byte[4]; ByteBuffer.wrap(fill_value).putInt(SPACE_FILL); // Initialize memory buffer for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) { buf_data[(indx * DIM_Y) + jndx] = Integer.valueOf(indx * jndx - jndx); } byte[] buf_array = HDFArray.IntegerToByte(buf_data); // Fill selection in memory try { H5.H5Dfill(fill_value, HDF5Constants.H5T_NATIVE_UINT, buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid); } catch (Exception err) { err.printStackTrace(); fail("H5.H5Diterate: " + err); } // Initialize the iterator structure ((H5D_iter_data)iter_data).fill_value = SPACE_FILL; ((H5D_iter_data)iter_data).fill_curr_coord = 0; // Set the coordinates of the selection ((H5D_iter_data)iter_data).fill_coords = new long[DIM_X * DIM_Y * SPACE_RANK]; /* Coordinates of selection */ for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) { ((H5D_iter_data)iter_data).fill_coords[2 * (indx * DIM_Y + jndx)] = indx; ((H5D_iter_data)iter_data).fill_coords[2 * (indx * DIM_Y + jndx) + 1] = jndx; } /* end for */ // Iterate through selection, verifying correct data H5D_iterate_cb iter_cb = new H5D_iter_callback(); int op_status = -1; try { op_status = H5.H5Diterate(buf_array, HDF5Constants.H5T_NATIVE_UINT, H5dsid, iter_cb, iter_data); } catch (Throwable err) { err.printStackTrace(); fail("H5.H5Diterate: " + err); } assertTrue("H5Diterate ", op_status == 0); buf_data = HDFArray.ByteToInteger(buf_array); // Verify memory buffer the hard way for (int indx = 0; indx < DIM_X; indx++) for (int jndx = 0; jndx < DIM_Y; jndx++) assertTrue("H5.H5Diterate: [" + indx + "," + jndx + "] " + buf_data[(indx * DIM_Y) + jndx], buf_data[(indx * DIM_Y) + jndx].compareTo(126) == 0); } @Test public void testH5Dvlen_get_buf_size() { String[] str_data = {"Parting", "is such", "sweet", "sorrow.", "Testing", "one", "two", "three.", "Dog,", "man's", "best", "friend.", "Diamonds", "are", "a", "girls!", "S A", "T U R", "D A Y", "night", "That's", "all", "folks", "!!!"}; long vl_size = -1; /* Number of bytes used */ long str_data_bytes = 0; for (int idx = 0; idx < str_data.length; idx++) str_data_bytes += str_data[idx].length() + 1; // Account for terminating null // Convert String[] to ArrayList[] format for VL data ArrayList[] vl_str_data = new ArrayList[str_data.length]; for (int i = 0; i < str_data.length; i++) { vl_str_data[i] = new ArrayList<>(); vl_str_data[i].add(str_data[i]); } _createVLStrDataset("dset", HDF5Constants.H5P_DEFAULT); try { if ((H5did >= 0) && (H5dtid >= 0)) H5.H5DwriteVL(H5did, H5dtid, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, vl_str_data); } catch (Exception e) { e.printStackTrace(); } try { vl_size = H5.H5Dvlen_get_buf_size(H5did, H5dtid, H5dsid); } catch (Exception e) { e.printStackTrace(); } assertTrue("H5Dvlen_get_buf_size " + vl_size + " == " + str_data_bytes, vl_size == str_data_bytes); } @Test // ISSUE: Triple-nested VL type (VL of VL of VL-String) - crashes in H5T__vlen_reclaim // This test uses H5Tvlen_create(H5T_VARIABLE_STRING) creating VL> // Note: Nested VL> works (see testH5DVLwrVL), but VL> crashes during H5Treclaim // Simple VL strings work (testH5Dvlen_write_read), double-nested VL works (testH5DVLwrVL) // This is the most complex VL case with three levels of variable sizing @Ignore("DISABLED: Triple-nested VL type (VL of VL of VL-String) crashes in H5T__vlen_reclaim during " + "memory cleanup") public void testH5Dvlen_string_buffer() throws Throwable { String dset_str_name = "VLStringdata"; long dset_str_id = HDF5Constants.H5I_INVALID_HID; long dtype_str_id = HDF5Constants.H5I_INVALID_HID; long dspace_id = HDF5Constants.H5I_INVALID_HID; long[] dims = {64}; long lsize = 1; String[] str_data0 = {"Parting", "is such", "sweet", "sorrow."}; String[] str_data1 = {"Testing", "one", "two", "three."}; String[] str_data2 = {"Dog,", "man's", "best", "friend."}; String[] str_data3 = {"Diamonds", "are", "a", "girls!"}; String[] str_data4 = {"S A", "T U R", "D A Y", "night"}; String[] str_data5 = {"That's", "all", "folks", "!!!"}; ArrayList[] vl_str_data = new ArrayList[6]; vl_str_data[0] = new ArrayList(Arrays.asList(str_data0)); vl_str_data[1] = new ArrayList(Arrays.asList(str_data1)); vl_str_data[2] = new ArrayList(Arrays.asList(str_data2)); vl_str_data[3] = new ArrayList(Arrays.asList(str_data3)); vl_str_data[4] = new ArrayList(Arrays.asList(str_data4)); vl_str_data[5] = new ArrayList(Arrays.asList(str_data5)); try { H5dtid = H5.H5Tcopy(HDF5Constants.H5T_C_S1); } catch (Throwable err) { err.printStackTrace(); fail("testH5Dvlen_string_buffer.H5.H5Tcopy: " + err); } assertTrue("testH5Dvlen_string_buffer.H5Tcopy: ", H5dtid >= 0); try { H5.H5Tset_size(H5dtid, HDF5Constants.H5T_VARIABLE); assertTrue("testH5Dvlen_string_buffer.H5Tis_variable_str", H5.H5Tis_variable_str(H5dtid)); } catch (Throwable err) { err.printStackTrace(); fail("testH5Dvlen_string_buffer.H5Tset_size: " + err); } try { dtype_str_id = H5.H5Tvlen_create(H5dtid); assertTrue("testH5Dvlen_string_buffer.H5Tvlen_create: ", dtype_str_id >= 0); } catch (Exception err) { if (dtype_str_id > 0) try { H5.H5Tclose(dtype_str_id); } catch (Exception ex) { } err.printStackTrace(); fail("testH5Dvlen_string_buffer: " + err); } try { dspace_id = H5.H5Screate_simple(1, dims, null); assertTrue(dspace_id > 0); dset_str_id = H5.H5Dcreate(H5fid, dset_str_name, dtype_str_id, dspace_id, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); assertTrue("testH5Dvlen_string_buffer: ", dset_str_id >= 0); H5.H5DwriteVL(dset_str_id, dtype_str_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, vl_str_data); } catch (Exception err) { if (dset_str_id > 0) try { H5.H5Dclose(dset_str_id); } catch (Exception ex) { } if (dtype_str_id > 0) try { H5.H5Tclose(dtype_str_id); } catch (Exception ex) { } err.printStackTrace(); fail("testH5Dvlen_string_buffer: " + err); } finally { if (dspace_id > 0) try { H5.H5Sclose(dspace_id); } catch (Exception ex) { } } H5.H5Fflush(H5fid, HDF5Constants.H5F_SCOPE_LOCAL); for (int j = 0; j < dims.length; j++) lsize *= dims[j]; ArrayList[] vl_readbuf = new ArrayList[4]; for (int j = 0; j < lsize; j++) vl_readbuf[j] = new ArrayList(); try { H5.H5DreadVL(dset_str_id, dtype_str_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, vl_readbuf); } catch (Exception ex) { ex.printStackTrace(); } assertTrue("testH5Dvlen_string_buffer:" + vl_readbuf[0].get(0), vl_str_data[0].get(0).equals(vl_readbuf[0].get(0))); assertTrue("testH5Dvlen_string_buffer:" + vl_readbuf[1].get(0), vl_str_data[1].get(0).equals(vl_readbuf[1].get(0))); assertTrue("testH5Dvlen_string_buffer:" + vl_readbuf[2].get(0), vl_str_data[2].get(0).equals(vl_readbuf[2].get(0))); assertTrue("testH5Dvlen_string_buffer:" + vl_readbuf[3].get(0), vl_str_data[3].get(0).equals(vl_readbuf[3].get(0))); } @Test public void testH5Dvlen_write_read() { String[] str_wdata = {"Parting", "is such", "sweet", "sorrow.", "Testing", "one", "two", "three.", "Dog,", "man's", "best", "friend.", "Diamonds", "are", "a", "girls!", "S A", "T U R", "D A Y", "night", "That's", "all", "folks", "!!!"}; // Convert String[] to ArrayList[] format for VL data ArrayList[] vl_wdata = new ArrayList[str_wdata.length]; for (int i = 0; i < str_wdata.length; i++) { vl_wdata[i] = new ArrayList<>(); vl_wdata[i].add(str_wdata[i]); } ArrayList[] vl_rdata = new ArrayList[DIM_X * DIM_Y]; for (int j = 0; j < vl_rdata.length; j++) vl_rdata[j] = new ArrayList(); _createVLStrDataset("dset", HDF5Constants.H5P_DEFAULT); try { if ((H5did >= 0) && (H5dtid >= 0)) H5.H5DwriteVL(H5did, H5dtid, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, vl_wdata); } catch (Exception e) { e.printStackTrace(); } try { if ((H5did >= 0) && (H5dtid >= 0)) H5.H5DreadVL(H5did, H5dtid, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, vl_rdata); } catch (Exception e) { e.printStackTrace(); } for (int v = 0; v < DIM_X * DIM_Y; v++) assertTrue("testH5Dvlen_write_read " + str_wdata[v] + " == " + vl_rdata[v].get(0), str_wdata[v].equals(vl_rdata[v].get(0))); } @Test public void testH5DVLwr() { String dset_int_name = "VLIntdata"; String dset_dbl_name = "VLDbldata"; long dset_int_id = HDF5Constants.H5I_INVALID_HID; long dset_dbl_id = HDF5Constants.H5I_INVALID_HID; long dtype_int_id = HDF5Constants.H5I_INVALID_HID; long dtype_dbl_id = HDF5Constants.H5I_INVALID_HID; long dspace_id = HDF5Constants.H5I_INVALID_HID; long[] dims = {4}; long lsize = 1; ArrayList[] vl_int_data = new ArrayList[4]; ArrayList[] vl_dbl_data = new ArrayList[4]; try { // Write Integer data vl_int_data[0] = new ArrayList(Arrays.asList(1)); vl_int_data[1] = new ArrayList(Arrays.asList(2, 3)); vl_int_data[2] = new ArrayList(Arrays.asList(4, 5, 6)); vl_int_data[3] = new ArrayList(Arrays.asList(7, 8, 9, 10)); Class dataClass = vl_int_data.getClass(); assertTrue("testH5DVLwr.getClass: " + dataClass, dataClass.isArray()); try { dtype_int_id = H5.H5Tvlen_create(HDF5Constants.H5T_STD_U32LE); assertTrue("testH5DVLwr.H5Tvlen_create: ", dtype_int_id >= 0); } catch (Exception err) { if (dtype_int_id > 0) try { H5.H5Tclose(dtype_int_id); } catch (Exception ex) { } err.printStackTrace(); fail("H5.testH5DVLwr: " + err); } try { dspace_id = H5.H5Screate_simple(1, dims, null); assertTrue(dspace_id > 0); dset_int_id = H5.H5Dcreate(H5fid, dset_int_name, dtype_int_id, dspace_id, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); assertTrue("testH5DVLwr: ", dset_int_id >= 0); H5.H5DwriteVL(dset_int_id, dtype_int_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, vl_int_data); } catch (Exception err) { if (dset_int_id > 0) try { H5.H5Dclose(dset_int_id); } catch (Exception ex) { } if (dtype_int_id > 0) try { H5.H5Tclose(dtype_int_id); } catch (Exception ex) { } err.printStackTrace(); fail("H5.testH5DVLwr: " + err); } finally { if (dspace_id > 0) try { H5.H5Sclose(dspace_id); } catch (Exception ex) { } } // Write Double data vl_dbl_data[0] = new ArrayList(Arrays.asList(1.1)); vl_dbl_data[1] = new ArrayList(Arrays.asList(2.2, 3.3)); vl_dbl_data[2] = new ArrayList(Arrays.asList(4.4, 5.5, 6.6)); vl_dbl_data[3] = new ArrayList(Arrays.asList(7.7, 8.8, 9.9, 10.0)); dataClass = vl_dbl_data.getClass(); assertTrue("testH5DVLwr.getClass: " + dataClass, dataClass.isArray()); try { dtype_dbl_id = H5.H5Tvlen_create(HDF5Constants.H5T_NATIVE_DOUBLE); assertTrue("testH5DVLwr.H5Tvlen_create: ", dtype_dbl_id >= 0); } catch (Exception err) { if (dtype_dbl_id > 0) try { H5.H5Tclose(dtype_dbl_id); } catch (Exception ex) { } err.printStackTrace(); fail("H5.testH5DVLwr: " + err); } try { dspace_id = H5.H5Screate_simple(1, dims, null); assertTrue(dspace_id > 0); dset_dbl_id = H5.H5Dcreate(H5fid, dset_dbl_name, dtype_dbl_id, dspace_id, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); assertTrue("testH5DVLwr: ", dset_dbl_id >= 0); H5.H5DwriteVL(dset_dbl_id, dtype_dbl_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, vl_dbl_data); } catch (Exception err) { if (dset_dbl_id > 0) try { H5.H5Dclose(dset_dbl_id); } catch (Exception ex) { } if (dtype_dbl_id > 0) try { H5.H5Tclose(dtype_dbl_id); } catch (Exception ex) { } err.printStackTrace(); fail("H5.testH5DVLwr: " + err); } finally { if (dspace_id > 0) try { H5.H5Sclose(dspace_id); } catch (Exception ex) { } } H5.H5Fflush(H5fid, HDF5Constants.H5F_SCOPE_LOCAL); for (int j = 0; j < dims.length; j++) lsize *= dims[j]; // Read Integer data ArrayList[] vl_int_readbuf = new ArrayList[4]; for (int j = 0; j < lsize; j++) vl_int_readbuf[j] = new ArrayList(); try { H5.H5DreadVL(dset_int_id, dtype_int_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, vl_int_readbuf); } catch (Exception ex) { ex.printStackTrace(); } assertTrue("testH5DVLwr:" + vl_int_readbuf[0].get(0), vl_int_data[0].get(0).equals(vl_int_readbuf[0].get(0))); assertTrue("testH5DVLwr:" + vl_int_readbuf[1].get(0), vl_int_data[1].get(0).equals(vl_int_readbuf[1].get(0))); assertTrue("testH5DVLwr:" + vl_int_readbuf[2].get(0), vl_int_data[2].get(0).equals(vl_int_readbuf[2].get(0))); assertTrue("testH5DVLwr:" + vl_int_readbuf[3].get(0), vl_int_data[3].get(0).equals(vl_int_readbuf[3].get(0))); // Read Double data ArrayList[] vl_dbl_readbuf = new ArrayList[4]; for (int j = 0; j < lsize; j++) vl_dbl_readbuf[j] = new ArrayList(); try { H5.H5DreadVL(dset_dbl_id, dtype_dbl_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, vl_dbl_readbuf); } catch (Exception ex) { ex.printStackTrace(); } assertTrue("testH5DVLwr:" + vl_dbl_readbuf[0].get(0), vl_dbl_data[0].get(0).equals(vl_dbl_readbuf[0].get(0))); assertTrue("testH5DVLwr:" + vl_dbl_readbuf[1].get(0), vl_dbl_data[1].get(0).equals(vl_dbl_readbuf[1].get(0))); assertTrue("testH5DVLwr:" + vl_dbl_readbuf[2].get(0), vl_dbl_data[2].get(0).equals(vl_dbl_readbuf[2].get(0))); assertTrue("testH5DVLwr:" + vl_dbl_readbuf[3].get(0), vl_dbl_data[3].get(0).equals(vl_dbl_readbuf[3].get(0))); } catch (Throwable err) { err.printStackTrace(); fail("H5.testH5DVLwr: " + err); } finally { if (dset_dbl_id > 0) try { H5.H5Dclose(dset_dbl_id); } catch (Exception ex) { } if (dset_int_id > 0) try { H5.H5Dclose(dset_int_id); } catch (Exception ex) { } if (dtype_dbl_id > 0) try { H5.H5Tclose(dtype_dbl_id); } catch (Exception ex) { } if (dtype_int_id > 0) try { H5.H5Tclose(dtype_int_id); } catch (Exception ex) { } } } @Test public void testH5DVLwrVL() { String dset_int_name = "VLIntdata"; long dset_int_id = HDF5Constants.H5I_INVALID_HID; long dtype_int_id = HDF5Constants.H5I_INVALID_HID; long base_dtype_int_id = HDF5Constants.H5I_INVALID_HID; long dspace_id = HDF5Constants.H5I_INVALID_HID; long[] dims = {4}; long lsize = 1; ArrayList[] base_vl_int_data = new ArrayList[4]; ArrayList[] vl_int_data = new ArrayList[4]; try { // Write Integer data vl_int_data[0] = new ArrayList(Arrays.asList(1)); vl_int_data[1] = new ArrayList(Arrays.asList(2, 3)); vl_int_data[2] = new ArrayList(Arrays.asList(4, 5, 6)); vl_int_data[3] = new ArrayList(Arrays.asList(7, 8, 9, 10)); Class dataClass = vl_int_data.getClass(); assertTrue("testH5DVLwrVL.getClass: " + dataClass, dataClass.isArray()); // Write VL data base_vl_int_data[0] = new ArrayList>(); base_vl_int_data[0].add(vl_int_data[0]); base_vl_int_data[1] = new ArrayList>(); base_vl_int_data[1].add(vl_int_data[0]); base_vl_int_data[1].add(vl_int_data[1]); base_vl_int_data[2] = new ArrayList>(); base_vl_int_data[2].add(vl_int_data[0]); base_vl_int_data[2].add(vl_int_data[1]); base_vl_int_data[2].add(vl_int_data[2]); base_vl_int_data[3] = new ArrayList>(); base_vl_int_data[3].add(vl_int_data[0]); base_vl_int_data[3].add(vl_int_data[1]); base_vl_int_data[3].add(vl_int_data[2]); base_vl_int_data[3].add(vl_int_data[3]); try { dtype_int_id = H5.H5Tvlen_create(HDF5Constants.H5T_STD_U32LE); assertTrue("testH5DVLwrVL.H5Tvlen_create: ", dtype_int_id >= 0); base_dtype_int_id = H5.H5Tvlen_create(dtype_int_id); assertTrue("testH5DVLwrVL.H5Tvlen_create: ", base_dtype_int_id >= 0); } catch (Exception err) { if (base_dtype_int_id > 0) try { H5.H5Tclose(base_dtype_int_id); } catch (Exception ex) { } if (dtype_int_id > 0) try { H5.H5Tclose(dtype_int_id); } catch (Exception ex) { } err.printStackTrace(); fail("H5.testH5DVLwrVL: " + err); } try { dspace_id = H5.H5Screate_simple(1, dims, null); assertTrue(dspace_id > 0); dset_int_id = H5.H5Dcreate(H5fid, dset_int_name, base_dtype_int_id, dspace_id, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); assertTrue("testH5DVLwrVL: ", dset_int_id >= 0); H5.H5DwriteVL(dset_int_id, base_dtype_int_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, base_vl_int_data); } catch (Exception err) { if (dset_int_id > 0) try { H5.H5Dclose(dset_int_id); } catch (Exception ex) { } if (dtype_int_id > 0) try { H5.H5Tclose(dtype_int_id); } catch (Exception ex) { } err.printStackTrace(); fail("H5.testH5DVLwrVL: " + err); } finally { if (dspace_id > 0) try { H5.H5Sclose(dspace_id); } catch (Exception ex) { } } H5.H5Fflush(H5fid, HDF5Constants.H5F_SCOPE_LOCAL); for (int j = 0; j < dims.length; j++) lsize *= dims[j]; // Read Integer data ArrayList[] base_vl_readbuf = new ArrayList[4]; for (int j = 0; j < lsize; j++) base_vl_readbuf[j] = new ArrayList>(); try { H5.H5DreadVL(dset_int_id, base_dtype_int_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, base_vl_readbuf); } catch (Exception ex) { ex.printStackTrace(); } ArrayList> vl_readbuf = (ArrayList>)base_vl_readbuf[0]; assertTrue("vl_readbuf 0 exists", vl_readbuf != null); ArrayList vl_readbuf_int = (ArrayList)(vl_readbuf.get(0)); /* * System.out.println(); System.out.println("vl_readbuf: " + vl_readbuf); * System.out.println("vl_readbuf_int: " + vl_readbuf_int); */ assertTrue("testH5DVLwrVL:" + vl_readbuf_int.get(0), vl_int_data[0].get(0).equals(vl_readbuf_int.get(0))); vl_readbuf = (ArrayList>)base_vl_readbuf[1]; vl_readbuf_int = (ArrayList)(vl_readbuf.get(1)); /* * System.out.println("vl_readbuf: " + vl_readbuf); System.out.println("vl_readbuf_int: " + * vl_readbuf_int); */ assertTrue("testH5DVLwrVL:" + vl_readbuf_int.get(1), vl_int_data[1].get(1).equals(vl_readbuf_int.get(1))); vl_readbuf = (ArrayList>)base_vl_readbuf[2]; vl_readbuf_int = (ArrayList)(vl_readbuf.get(2)); /* * System.out.println("vl_readbuf: " + vl_readbuf); System.out.println("vl_readbuf_int: " + * vl_readbuf_int); */ assertTrue("testH5DVLwrVL:" + vl_readbuf_int.get(2), vl_int_data[2].get(2).equals(vl_readbuf_int.get(2))); vl_readbuf = (ArrayList>)base_vl_readbuf[3]; vl_readbuf_int = (ArrayList)(vl_readbuf.get(3)); /* * System.out.println("vl_readbuf: " + vl_readbuf); System.out.println("vl_readbuf_int: " + * vl_readbuf_int); */ assertTrue("testH5DVLwrVL:" + vl_readbuf_int.get(3), vl_int_data[3].get(3).equals(vl_readbuf_int.get(3))); } catch (Throwable err) { err.printStackTrace(); fail("H5.testH5DVLwrVL: " + err); } finally { if (dset_int_id > 0) try { H5.H5Dclose(dset_int_id); } catch (Exception ex) { } if (dtype_int_id > 0) try { H5.H5Tclose(dtype_int_id); } catch (Exception ex) { } if (base_dtype_int_id > 0) try { H5.H5Tclose(base_dtype_int_id); } catch (Exception ex) { } } } @Test public void testH5DArraywr() { String dset_int_name = "ArrayIntdata"; long dset_int_id = HDF5Constants.H5I_INVALID_HID; long dtype_int_id = HDF5Constants.H5I_INVALID_HID; long dspace_id = HDF5Constants.H5I_INVALID_HID; long[] dims = {4}; long lsize = 1; ArrayList[] arr_int_data = new ArrayList[4]; try { // Write Integer data arr_int_data[0] = new ArrayList(Arrays.asList(1, 2, 3, 4)); arr_int_data[1] = new ArrayList(Arrays.asList(2, 3, 4, 5)); arr_int_data[2] = new ArrayList(Arrays.asList(4, 5, 6, 7)); arr_int_data[3] = new ArrayList(Arrays.asList(7, 8, 9, 10)); Class dataClass = arr_int_data.getClass(); assertTrue("testH5DArraywr.getClass: " + dataClass, dataClass.isArray()); try { dtype_int_id = H5.H5Tarray_create(HDF5Constants.H5T_STD_U32LE, 1, dims); assertTrue("testH5DArraywr.H5Tarray_create: ", dtype_int_id >= 0); } catch (Exception err) { if (dtype_int_id > 0) try { H5.H5Tclose(dtype_int_id); } catch (Exception ex) { } err.printStackTrace(); fail("H5.testH5DArraywr: " + err); } try { dspace_id = H5.H5Screate_simple(1, dims, null); assertTrue(dspace_id > 0); dset_int_id = H5.H5Dcreate(H5fid, dset_int_name, dtype_int_id, dspace_id, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); assertTrue("testH5DVLwr: ", dset_int_id >= 0); H5.H5DwriteVL(dset_int_id, dtype_int_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, arr_int_data); } catch (Exception err) { if (dset_int_id > 0) try { H5.H5Dclose(dset_int_id); } catch (Exception ex) { } if (dtype_int_id > 0) try { H5.H5Tclose(dtype_int_id); } catch (Exception ex) { } err.printStackTrace(); fail("H5.testH5DVLwr: " + err); } finally { if (dspace_id > 0) try { H5.H5Sclose(dspace_id); } catch (Exception ex) { } } H5.H5Fflush(H5fid, HDF5Constants.H5F_SCOPE_LOCAL); for (int j = 0; j < dims.length; j++) lsize *= dims[j]; // Read Integer data ArrayList[] arr_readbuf = new ArrayList[4]; for (int j = 0; j < lsize; j++) arr_readbuf[j] = new ArrayList(); try { H5.H5DreadVL(dset_int_id, dtype_int_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, arr_readbuf); } catch (Exception ex) { ex.printStackTrace(); } assertTrue("testH5DVLwr:" + arr_readbuf[0].get(0), arr_int_data[0].get(0).equals(arr_readbuf[0].get(0))); assertTrue("testH5DVLwr:" + arr_readbuf[1].get(0), arr_int_data[1].get(0).equals(arr_readbuf[1].get(0))); assertTrue("testH5DVLwr:" + arr_readbuf[2].get(0), arr_int_data[2].get(0).equals(arr_readbuf[2].get(0))); assertTrue("testH5DVLwr:" + arr_readbuf[3].get(0), arr_int_data[3].get(0).equals(arr_readbuf[3].get(0))); } catch (Throwable err) { err.printStackTrace(); fail("H5.testH5DArraywr: " + err); } finally { if (dset_int_id > 0) try { H5.H5Dclose(dset_int_id); } catch (Exception ex) { } if (dtype_int_id > 0) try { H5.H5Tclose(dtype_int_id); } catch (Exception ex) { } } } @Test public void testH5DArray_string_buffer() throws Throwable { String dset_str_name = "ArrayStringdata"; long dset_str_id = HDF5Constants.H5I_INVALID_HID; long dtype_str_id = HDF5Constants.H5I_INVALID_HID; long dspace_id = HDF5Constants.H5I_INVALID_HID; long[] strdims = {4}; long[] dims = {6}; long lsize = 1; String[] str_data0 = {"Parting", "is such", "sweet", "sorrow."}; String[] str_data1 = {"Testing", "one", "two", "three."}; String[] str_data2 = {"Dog,", "man's", "best", "friend."}; String[] str_data3 = {"Diamonds", "are", "a", "girls!"}; String[] str_data4 = {"S A", "T U R", "D A Y", "night"}; String[] str_data5 = {"That's", "all", "folks", "!!!"}; ArrayList[] arr_str_data = new ArrayList[6]; arr_str_data[0] = new ArrayList(Arrays.asList(str_data0)); arr_str_data[1] = new ArrayList(Arrays.asList(str_data1)); arr_str_data[2] = new ArrayList(Arrays.asList(str_data2)); arr_str_data[3] = new ArrayList(Arrays.asList(str_data3)); arr_str_data[4] = new ArrayList(Arrays.asList(str_data4)); arr_str_data[5] = new ArrayList(Arrays.asList(str_data5)); try { H5dtid = H5.H5Tcopy(HDF5Constants.H5T_C_S1); } catch (Throwable err) { err.printStackTrace(); fail("testH5DArray_string_buffer.H5.H5Tcopy: " + err); } assertTrue("testH5DArray_string_buffer.H5Tcopy: ", H5dtid >= 0); try { H5.H5Tset_size(H5dtid, HDF5Constants.H5T_VARIABLE); assertTrue("testH5DArray_string_buffer.H5Tis_variable_str", H5.H5Tis_variable_str(H5dtid)); } catch (Throwable err) { err.printStackTrace(); fail("testH5DArray_string_buffer.H5Tset_size: " + err); } try { dtype_str_id = H5.H5Tarray_create(H5dtid, 1, strdims); assertTrue("testH5DArray_string_buffer.H5Tarray_create: ", dtype_str_id >= 0); } catch (Exception err) { if (dtype_str_id > 0) try { H5.H5Tclose(dtype_str_id); } catch (Exception ex) { } err.printStackTrace(); fail("testH5DArray_string_buffer: " + err); } try { dspace_id = H5.H5Screate_simple(1, dims, null); assertTrue(dspace_id > 0); dset_str_id = H5.H5Dcreate(H5fid, dset_str_name, dtype_str_id, dspace_id, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); assertTrue("testH5DArray_string_buffer: ", dset_str_id >= 0); H5.H5DwriteVL(dset_str_id, dtype_str_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, arr_str_data); } catch (Exception err) { if (dset_str_id > 0) try { H5.H5Dclose(dset_str_id); } catch (Exception ex) { } if (dtype_str_id > 0) try { H5.H5Tclose(dtype_str_id); } catch (Exception ex) { } err.printStackTrace(); fail("testH5DArray_string_buffer: " + err); } finally { if (dspace_id > 0) try { H5.H5Sclose(dspace_id); } catch (Exception ex) { } } H5.H5Fflush(H5fid, HDF5Constants.H5F_SCOPE_LOCAL); for (int j = 0; j < dims.length; j++) lsize *= dims[j]; ArrayList[] arr_readbuf = new ArrayList[6]; for (int j = 0; j < lsize; j++) arr_readbuf[j] = new ArrayList(); try { H5.H5DreadVL(dset_str_id, dtype_str_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, arr_readbuf); } catch (Exception ex) { ex.printStackTrace(); } finally { if (dset_str_id > 0) try { H5.H5Dclose(dset_str_id); } catch (Exception ex) { } if (dtype_str_id > 0) try { H5.H5Tclose(dtype_str_id); } catch (Exception ex) { } } assertTrue("testH5DArray_string_buffer:" + arr_readbuf[0].get(0), arr_str_data[0].get(0).equals(arr_readbuf[0].get(0))); assertTrue("testH5DArray_string_buffer:" + arr_readbuf[1].get(0), arr_str_data[1].get(0).equals(arr_readbuf[1].get(0))); assertTrue("testH5DArray_string_buffer:" + arr_readbuf[2].get(0), arr_str_data[2].get(0).equals(arr_readbuf[2].get(0))); assertTrue("testH5DArray_string_buffer:" + arr_readbuf[3].get(0), arr_str_data[3].get(0).equals(arr_readbuf[3].get(0))); } @Test public void testH5DArrayenum_rw() { String dset_enum_name = "ArrayEnumdata"; long dset_enum_id = HDF5Constants.H5I_INVALID_HID; long dtype_enum_id = HDF5Constants.H5I_INVALID_HID; long dtype_arr_enum_id = HDF5Constants.H5I_INVALID_HID; long dspace_id = HDF5Constants.H5I_INVALID_HID; long[] dims = {4}; long lsize = 1; String enum_type = "Enum_type"; byte[] enum_val = new byte[4]; String enum_name = null; // Create a enumerate datatype try { dtype_enum_id = H5.H5Tcreate(HDF5Constants.H5T_ENUM, (long)1); assertTrue("testH5DArrayenum_wr.H5Tarray_create: ", dtype_enum_id >= 0); } catch (Throwable err) { if (dtype_enum_id > 0) try { H5.H5Tclose(dtype_enum_id); } catch (Exception ex) { } err.printStackTrace(); fail("testH5DArrayenum_rw:H5Tcreate " + err); } try { enum_val[0] = 10; H5.H5Tenum_insert(dtype_enum_id, "RED", enum_val); enum_val[0] = 11; H5.H5Tenum_insert(dtype_enum_id, "GREEN", enum_val); enum_val[0] = 12; H5.H5Tenum_insert(dtype_enum_id, "BLUE", enum_val); enum_val[0] = 13; H5.H5Tenum_insert(dtype_enum_id, "ORANGE", enum_val); enum_val[0] = 14; H5.H5Tenum_insert(dtype_enum_id, "YELLOW", enum_val); // Query member number and member index by member name, for enumeration type. assertTrue("Can't get member number", H5.H5Tget_nmembers(dtype_enum_id) == 5); assertTrue("Can't get correct index number", H5.H5Tget_member_index(dtype_enum_id, "ORANGE") == 3); // Query member value by member name, for enumeration type H5.H5Tenum_valueof(dtype_enum_id, "ORANGE", enum_val); assertTrue("Incorrect value for enum member", enum_val[0] == 13); // Commit enumeration datatype and close it */ H5.H5Tcommit(H5fid, enum_type, dtype_enum_id, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); H5.H5Tclose(dtype_enum_id); // Open the dataytpe for query dtype_enum_id = H5.H5Topen(H5fid, enum_type, HDF5Constants.H5P_DEFAULT); assertTrue("testH5DArrayenum_rw:H5Tcreate", dtype_enum_id >= 0); // Query member number and member index by member name, for enumeration type assertTrue("Can't get member number", H5.H5Tget_nmembers(dtype_enum_id) == 5); assertTrue("Can't get correct index number", H5.H5Tget_member_index(dtype_enum_id, "ORANGE") == 3); // Query member value by member name, for enumeration type H5.H5Tenum_valueof(dtype_enum_id, "ORANGE", enum_val); assertTrue("Incorrect value for enum member", enum_val[0] == 13); // Query member value by member index, for enumeration type H5.H5Tget_member_value(dtype_enum_id, 2, enum_val); assertTrue("Incorrect value for enum member", enum_val[0] == 12); // Query member name by member value, for enumeration type enum_val[0] = 14; enum_name = H5.H5Tenum_nameof(dtype_enum_id, enum_val, 16); assertTrue("Incorrect name for enum member", enum_name.compareTo("YELLOW") == 0); ArrayList[] arr_enum_data = new ArrayList[4]; try { // Write Integer data arr_enum_data[0] = new ArrayList(Arrays.asList(10, 11, 12, 13)); arr_enum_data[1] = new ArrayList(Arrays.asList(11, 12, 13, 14)); arr_enum_data[2] = new ArrayList(Arrays.asList(12, 13, 14, 10)); arr_enum_data[3] = new ArrayList(Arrays.asList(13, 14, 10, 11)); Class dataClass = arr_enum_data.getClass(); assertTrue("testH5DArrayenum_wr.getClass: " + dataClass, dataClass.isArray()); try { dtype_arr_enum_id = H5.H5Tarray_create(HDF5Constants.H5T_STD_U32LE, 1, dims); assertTrue("testH5DArrayenum_wr.H5Tarray_create: ", dtype_arr_enum_id >= 0); } catch (Exception err) { if (dtype_arr_enum_id > 0) try { H5.H5Tclose(dtype_arr_enum_id); } catch (Exception ex) { } err.printStackTrace(); fail("H5.testH5DArrayenum_wr: " + err); } dspace_id = H5.H5Screate_simple(1, dims, null); assertTrue(dspace_id > 0); dset_enum_id = H5.H5Dcreate(H5fid, dset_enum_name, dtype_arr_enum_id, dspace_id, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); assertTrue("testH5DVLwr: ", dset_enum_id >= 0); H5.H5DwriteVL(dset_enum_id, dtype_arr_enum_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, arr_enum_data); } catch (Throwable err) { if (dset_enum_id > 0) try { H5.H5Dclose(dset_enum_id); } catch (Exception ex) { } if (dtype_enum_id > 0) try { H5.H5Tclose(dtype_enum_id); } catch (Exception ex) { } if (dtype_arr_enum_id > 0) try { H5.H5Tclose(dtype_arr_enum_id); } catch (Exception ex) { } err.printStackTrace(); fail("testH5DArrayenum_rw:query " + err); } finally { if (dspace_id > 0) try { H5.H5Sclose(dspace_id); } catch (Exception ex) { } } H5.H5Fflush(H5fid, HDF5Constants.H5F_SCOPE_LOCAL); for (int j = 0; j < dims.length; j++) lsize *= dims[j]; // Read Integer data ArrayList[] arr_readbuf = new ArrayList[4]; for (int j = 0; j < lsize; j++) arr_readbuf[j] = new ArrayList(); try { H5.H5DreadVL(dset_enum_id, dtype_arr_enum_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, arr_readbuf); } catch (Exception ex) { ex.printStackTrace(); } assertTrue("testH5DVLArrayenum_wr:" + arr_readbuf[0].get(0), arr_enum_data[0].get(0).equals(arr_readbuf[0].get(0))); assertTrue("testH5DVLArrayenum_wr:" + arr_readbuf[1].get(0), arr_enum_data[1].get(0).equals(arr_readbuf[1].get(0))); assertTrue("testH5DVLArrayenum_wr:" + arr_readbuf[2].get(0), arr_enum_data[2].get(0).equals(arr_readbuf[2].get(0))); assertTrue("testH5DVLArrayenum_wr:" + arr_readbuf[3].get(0), arr_enum_data[3].get(0).equals(arr_readbuf[3].get(0))); } catch (Throwable err) { err.printStackTrace(); fail("H5.testH5DArrayenum_wr: " + err); } finally { if (dset_enum_id > 0) try { H5.H5Dclose(dset_enum_id); } catch (Exception ex) { } if (dtype_enum_id > 0) try { H5.H5Tclose(dtype_enum_id); } catch (Exception ex) { } if (dtype_arr_enum_id > 0) try { H5.H5Tclose(dtype_arr_enum_id); } catch (Exception ex) { } } } @Test public void testH5Dwrite_readCompound() { String dset_name = "CompoundData"; long dset_id = HDF5Constants.H5I_INVALID_HID; long compound_type_id = HDF5Constants.H5I_INVALID_HID; long dataspace_id = HDF5Constants.H5I_INVALID_HID; final int ARRAY_SIZE = 4; // Create test data - 4 sensor readings ArrayList[] write_data = new ArrayList[ARRAY_SIZE]; write_data[0] = new TestSensor(1153, "Exterior (static)", 53.23, 24.57).toArrayList(); write_data[1] = new TestSensor(1184, "Intake", 55.12, 22.95).toArrayList(); write_data[2] = new TestSensor(1027, "Intake manifold", 103.55, 31.23).toArrayList(); write_data[3] = new TestSensor(1313, "Exhaust manifold", 1252.89, 84.11).toArrayList(); try { // Create compound datatype compound_type_id = TestSensor.createMemType(); assertTrue("testH5Dwrite_readCompound: compound type created", compound_type_id >= 0); // Create dataspace (1D, 4 elements) long[] dims = {ARRAY_SIZE}; dataspace_id = H5.H5Screate_simple(1, dims, null); assertTrue("testH5Dwrite_readCompound: dataspace created", dataspace_id >= 0); // Create dataset dset_id = H5.H5Dcreate(H5fid, dset_name, compound_type_id, dataspace_id, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); assertTrue("testH5Dwrite_readCompound: dataset created", dset_id >= 0); // Write compound data H5.H5DwriteVL(dset_id, compound_type_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, write_data); H5.H5Fflush(H5fid, HDF5Constants.H5F_SCOPE_LOCAL); // Read compound data back ArrayList[] read_data = new ArrayList[ARRAY_SIZE]; H5.H5DreadVL(dset_id, compound_type_id, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, read_data); // Validate sensor 0 assertNotNull("testH5Dwrite_readCompound: read_data[0] not null", read_data[0]); TestSensor sensor0 = new TestSensor(read_data[0]); assertEquals("testH5Dwrite_readCompound: sensor0 serial_no", 1153, sensor0.serial_no); assertEquals("testH5Dwrite_readCompound: sensor0 location", "Exterior (static)", sensor0.location.trim()); assertEquals("testH5Dwrite_readCompound: sensor0 temperature", 53.23, sensor0.temperature, 0.01); assertEquals("testH5Dwrite_readCompound: sensor0 pressure", 24.57, sensor0.pressure, 0.01); // Validate sensor 1 assertNotNull("testH5Dwrite_readCompound: read_data[1] not null", read_data[1]); TestSensor sensor1 = new TestSensor(read_data[1]); assertEquals("testH5Dwrite_readCompound: sensor1 serial_no", 1184, sensor1.serial_no); assertEquals("testH5Dwrite_readCompound: sensor1 location", "Intake", sensor1.location.trim()); assertEquals("testH5Dwrite_readCompound: sensor1 temperature", 55.12, sensor1.temperature, 0.01); assertEquals("testH5Dwrite_readCompound: sensor1 pressure", 22.95, sensor1.pressure, 0.01); // Validate sensor 2 assertNotNull("testH5Dwrite_readCompound: read_data[2] not null", read_data[2]); TestSensor sensor2 = new TestSensor(read_data[2]); assertEquals("testH5Dwrite_readCompound: sensor2 serial_no", 1027, sensor2.serial_no); assertEquals("testH5Dwrite_readCompound: sensor2 location", "Intake manifold", sensor2.location.trim()); assertEquals("testH5Dwrite_readCompound: sensor2 temperature", 103.55, sensor2.temperature, 0.01); assertEquals("testH5Dwrite_readCompound: sensor2 pressure", 31.23, sensor2.pressure, 0.01); // Validate sensor 3 assertNotNull("testH5Dwrite_readCompound: read_data[3] not null", read_data[3]); TestSensor sensor3 = new TestSensor(read_data[3]); assertEquals("testH5Dwrite_readCompound: sensor3 serial_no", 1313, sensor3.serial_no); assertEquals("testH5Dwrite_readCompound: sensor3 location", "Exhaust manifold", sensor3.location.trim()); assertEquals("testH5Dwrite_readCompound: sensor3 temperature", 1252.89, sensor3.temperature, 0.01); assertEquals("testH5Dwrite_readCompound: sensor3 pressure", 84.11, sensor3.pressure, 0.01); } catch (Throwable err) { err.printStackTrace(); fail("H5.testH5Dwrite_readCompound: " + err); } finally { if (dset_id > 0) try { H5.H5Dclose(dset_id); } catch (Exception ex) { } if (compound_type_id > 0) try { H5.H5Tclose(compound_type_id); } catch (Exception ex) { } if (dataspace_id > 0) try { H5.H5Sclose(dataspace_id); } catch (Exception ex) { } } } /** * Test H5Dwrite_VLStrings and H5Dread_VLStrings round-trip */ @Ignore public void testH5D_VLStrings_write_read_roundtrip() { String dsetName = "/VLStringDataset_roundtrip"; long strType = HDF5Constants.H5I_INVALID_HID; long dsetId = HDF5Constants.H5I_INVALID_HID; long dsetSpace = HDF5Constants.H5I_INVALID_HID; try { // Create variable-length string type strType = H5.H5Tcopy(HDF5Constants.H5T_C_S1); H5.H5Tset_size(strType, HDF5Constants.H5T_VARIABLE); // Create dataspace for 2D array of strings long[] dims = {2, 3}; dsetSpace = H5.H5Screate_simple(2, dims, null); // Create dataset dsetId = H5.H5Dcreate(H5fid, dsetName, strType, dsetSpace, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); assertTrue("H5Dcreate failed", dsetId >= 0); // Write 6 strings (2x3 array flattened) String[] writeData = {"String 0", "String 1", "String 2", "String 3", "String 4", "String 5"}; int status = H5.H5Dwrite_VLStrings(dsetId, strType, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, writeData); assertTrue("H5Dwrite_VLStrings failed", status >= 0); // Read back String[] readData = new String[6]; status = H5.H5Dread_VLStrings(dsetId, strType, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, readData); assertTrue("H5Dread_VLStrings failed", status >= 0); // Verify all strings for (int i = 0; i < 6; i++) { assertEquals("String " + i + " mismatch", writeData[i], readData[i]); } System.out.println("testH5D_VLStrings_write_read_roundtrip: PASSED"); } catch (Exception ex) { ex.printStackTrace(); fail("Exception: " + ex.getMessage()); } finally { try { if (dsetId >= 0) H5.H5Dclose(dsetId); } catch (Exception ex) { } try { if (dsetSpace >= 0) H5.H5Sclose(dsetSpace); } catch (Exception ex) { } try { if (strType >= 0) H5.H5Tclose(strType); } catch (Exception ex) { } } } /** * Test round-trip with empty strings */ @Ignore public void testH5D_VLStrings_roundtrip_empty() { String dsetName = "/VLStringDataset_empty"; long strType = HDF5Constants.H5I_INVALID_HID; long dsetId = HDF5Constants.H5I_INVALID_HID; long dsetSpace = HDF5Constants.H5I_INVALID_HID; try { strType = H5.H5Tcopy(HDF5Constants.H5T_C_S1); H5.H5Tset_size(strType, HDF5Constants.H5T_VARIABLE); long[] dims = {4}; dsetSpace = H5.H5Screate_simple(1, dims, null); dsetId = H5.H5Dcreate(H5fid, dsetName, strType, dsetSpace, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); // Write mix of empty and non-empty strings String[] writeData = {"", "Not empty", "", "Also not empty"}; int status = H5.H5Dwrite_VLStrings(dsetId, strType, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, writeData); assertTrue("H5Dwrite_VLStrings failed", status >= 0); // Read back String[] readData = new String[4]; status = H5.H5Dread_VLStrings(dsetId, strType, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, readData); assertTrue("H5Dread_VLStrings failed", status >= 0); // Verify empty strings preserved assertEquals("First should be empty", "", readData[0]); assertEquals("Second should match", "Not empty", readData[1]); assertEquals("Third should be empty", "", readData[2]); assertEquals("Fourth should match", "Also not empty", readData[3]); System.out.println("testH5D_VLStrings_roundtrip_empty: PASSED"); } catch (Exception ex) { ex.printStackTrace(); fail("Exception: " + ex.getMessage()); } finally { try { if (dsetId >= 0) H5.H5Dclose(dsetId); } catch (Exception ex) { } try { if (dsetSpace >= 0) H5.H5Sclose(dsetSpace); } catch (Exception ex) { } try { if (strType >= 0) H5.H5Tclose(strType); } catch (Exception ex) { } } } /** * Test round-trip with large strings */ @Ignore public void testH5D_VLStrings_roundtrip_large() { String dsetName = "/VLStringDataset_large"; long strType = HDF5Constants.H5I_INVALID_HID; long dsetId = HDF5Constants.H5I_INVALID_HID; long dsetSpace = HDF5Constants.H5I_INVALID_HID; try { strType = H5.H5Tcopy(HDF5Constants.H5T_C_S1); H5.H5Tset_size(strType, HDF5Constants.H5T_VARIABLE); long[] dims = {3}; dsetSpace = H5.H5Screate_simple(1, dims, null); dsetId = H5.H5Dcreate(H5fid, dsetName, strType, dsetSpace, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT); // Create large strings (>1KB each) StringBuilder sb = new StringBuilder(); for (int i = 0; i < 200; i++) { sb.append("This is test string content "); } String largeString = sb.toString(); String[] writeData = {largeString + " [0]", largeString + " [1]", largeString + " [2]"}; int status = H5.H5Dwrite_VLStrings(dsetId, strType, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, writeData); assertTrue("H5Dwrite_VLStrings failed", status >= 0); String[] readData = new String[3]; status = H5.H5Dread_VLStrings(dsetId, strType, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, readData); assertTrue("H5Dread_VLStrings failed", status >= 0); for (int i = 0; i < 3; i++) { assertEquals("Large string " + i + " mismatch", writeData[i], readData[i]); assertTrue("String should be > 1KB", readData[i].length() > 1024); } System.out.println("testH5D_VLStrings_roundtrip_large: PASSED"); } catch (Exception ex) { ex.printStackTrace(); fail("Exception: " + ex.getMessage()); } finally { try { if (dsetId >= 0) H5.H5Dclose(dsetId); } catch (Exception ex) { } try { if (dsetSpace >= 0) H5.H5Sclose(dsetSpace); } catch (Exception ex) { } try { if (strType >= 0) H5.H5Tclose(strType); } catch (Exception ex) { } } } }