mirror of
https://github.com/HDFGroup/hdf5.git
synced 2026-09-25 04:09:44 +03:00
Allen Byrne
b754dcb8f2
FFM build requires Java 25, Jextract 25. Generates FFM bindings during configure. JNI is default when the requirements are not met or can be forced. Presets added for maven and FFM - JNI is default selection. Enhanced Maven options will work with either JNI or FFM New Workflows for testing and maven uploads. Extensive documentation changes for java.
2694 lines
107 KiB
Java
2694 lines
107 KiB
Java
package jtest;
|
|
|
|
import static org.junit.Assert.*;
|
|
|
|
import static jtest.FfmTestSupport.*;
|
|
|
|
import java.lang.foreign.Arena;
|
|
import java.lang.foreign.MemorySegment;
|
|
import java.lang.foreign.ValueLayout;
|
|
|
|
import org.hdfgroup.javahdf5.hdf5_h;
|
|
import org.junit.After;
|
|
import org.junit.Before;
|
|
import org.junit.Rule;
|
|
import org.junit.Test;
|
|
import org.junit.rules.TestName;
|
|
|
|
public class TestH5Pffm {
|
|
@Rule
|
|
public TestName testname = new TestName();
|
|
|
|
private static final String H5_FILE = "testPffm.h5";
|
|
|
|
long H5fid = hdf5_h.H5I_INVALID_HID();
|
|
long H5fcpl = hdf5_h.H5I_INVALID_HID();
|
|
long H5fapl = hdf5_h.H5I_INVALID_HID();
|
|
long H5dcpl = hdf5_h.H5I_INVALID_HID();
|
|
long H5dxpl = hdf5_h.H5I_INVALID_HID();
|
|
|
|
private static void _deleteFile(String filename)
|
|
{
|
|
java.io.File file = new java.io.File(filename);
|
|
if (file.exists()) {
|
|
try {
|
|
file.delete();
|
|
}
|
|
catch (SecurityException e) {
|
|
// Ignore
|
|
}
|
|
}
|
|
}
|
|
|
|
@Before
|
|
public void createH5file()
|
|
{
|
|
// Ensure HDF5 library is initialized (prevents FFM constant initialization issues)
|
|
hdf5_h.H5open();
|
|
|
|
H5fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("H5Pcreate fcpl", isValidId(H5fcpl));
|
|
|
|
H5fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl", isValidId(H5fapl));
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
H5fid = hdf5_h.H5Fcreate(stringToSegment(arena, H5_FILE), hdf5_h.H5F_ACC_TRUNC(), H5fcpl, H5fapl);
|
|
}
|
|
assertTrue("H5Fcreate", isValidId(H5fid));
|
|
}
|
|
|
|
@After
|
|
public void deleteH5file()
|
|
{
|
|
if (H5dxpl > 0)
|
|
try {
|
|
hdf5_h.H5Pclose(H5dxpl);
|
|
}
|
|
catch (Exception ex) {
|
|
}
|
|
if (H5dcpl > 0)
|
|
try {
|
|
hdf5_h.H5Pclose(H5dcpl);
|
|
}
|
|
catch (Exception ex) {
|
|
}
|
|
if (H5fid > 0)
|
|
try {
|
|
hdf5_h.H5Fclose(H5fid);
|
|
}
|
|
catch (Exception ex) {
|
|
}
|
|
if (H5fapl > 0)
|
|
try {
|
|
hdf5_h.H5Pclose(H5fapl);
|
|
}
|
|
catch (Exception ex) {
|
|
}
|
|
if (H5fcpl > 0)
|
|
try {
|
|
hdf5_h.H5Pclose(H5fcpl);
|
|
}
|
|
catch (Exception ex) {
|
|
}
|
|
|
|
_deleteFile(H5_FILE);
|
|
}
|
|
|
|
// =========================
|
|
// Generic Property List Tests
|
|
// =========================
|
|
|
|
@Test
|
|
public void testH5Pcreate()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create dataset creation property list
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Verify it's the right class
|
|
long cls = hdf5_h.H5Pget_class(dcpl);
|
|
assertTrue("H5Pget_class failed", isValidId(cls));
|
|
|
|
int equal = hdf5_h.H5Pequal(cls, hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("Class should match H5P_DATASET_CREATE", equal > 0);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pclose()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create property list
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Close it
|
|
int result = hdf5_h.H5Pclose(dcpl);
|
|
assertTrue("H5Pclose failed", isSuccess(result));
|
|
|
|
// Verify it's closed (H5Iis_valid should return false)
|
|
int valid = hdf5_h.H5Iis_valid(dcpl);
|
|
assertEquals("Property list should be invalid after close", 0, valid);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pcopy()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create dataset creation property list with chunk settings
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Set chunk dimensions
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkSeg = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkSeg, chunkDims);
|
|
hdf5_h.H5Pset_chunk(dcpl, 2, chunkSeg);
|
|
|
|
// Copy property list
|
|
long dcpl_copy = hdf5_h.H5Pcopy(dcpl);
|
|
assertTrue("H5Pcopy failed", isValidId(dcpl_copy));
|
|
|
|
// Verify copy has same settings
|
|
MemorySegment outChunk = allocateLongArray(arena, 2);
|
|
int ndims = hdf5_h.H5Pget_chunk(dcpl_copy, 2, outChunk);
|
|
assertEquals("Should have 2 dimensions", 2, ndims);
|
|
|
|
long[] retrieved = new long[2];
|
|
copyFromSegment(outChunk, retrieved);
|
|
assertArrayEquals("Chunk dimensions should match in copy", chunkDims, retrieved);
|
|
|
|
hdf5_h.H5Pclose(dcpl_copy);
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pequal()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create two identical property lists
|
|
long dcpl1 = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
long dcpl2 = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
|
|
// They should be equal (both are default dataset create plists)
|
|
int equal = hdf5_h.H5Pequal(dcpl1, dcpl2);
|
|
assertTrue("Default property lists should be equal", equal > 0);
|
|
|
|
// Modify one
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkSeg = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkSeg, chunkDims);
|
|
hdf5_h.H5Pset_chunk(dcpl1, 2, chunkSeg);
|
|
|
|
// Now they should be different
|
|
equal = hdf5_h.H5Pequal(dcpl1, dcpl2);
|
|
assertEquals("Modified property lists should not be equal", 0, equal);
|
|
|
|
hdf5_h.H5Pclose(dcpl2);
|
|
hdf5_h.H5Pclose(dcpl1);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_class()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create different types of property lists
|
|
long fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
|
|
// Get their classes
|
|
long fcpl_class = hdf5_h.H5Pget_class(fcpl);
|
|
long dcpl_class = hdf5_h.H5Pget_class(dcpl);
|
|
|
|
// Verify correct classes
|
|
int fcpl_equal = hdf5_h.H5Pequal(fcpl_class, hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("FCPL class should match FILE_CREATE", fcpl_equal > 0);
|
|
|
|
int dcpl_equal = hdf5_h.H5Pequal(dcpl_class, hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("DCPL class should match DATASET_CREATE", dcpl_equal > 0);
|
|
|
|
// Verify they're different classes
|
|
int different = hdf5_h.H5Pequal(fcpl_class, dcpl_class);
|
|
assertEquals("FILE_CREATE and DATASET_CREATE should be different classes", 0, different);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
hdf5_h.H5Pclose(fcpl);
|
|
}
|
|
}
|
|
|
|
// =========================
|
|
// File Creation Property Tests
|
|
// =========================
|
|
|
|
@Test
|
|
public void testH5Pset_userblock()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("H5Pcreate fcpl failed", isValidId(fcpl));
|
|
|
|
// Set user block size (must be power of 2 >= 512)
|
|
long userblock_size = 1024;
|
|
int result = hdf5_h.H5Pset_userblock(fcpl, userblock_size);
|
|
assertTrue("H5Pset_userblock failed", isSuccess(result));
|
|
|
|
// Get user block size back
|
|
MemorySegment sizeSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
result = hdf5_h.H5Pget_userblock(fcpl, sizeSeg);
|
|
assertTrue("H5Pget_userblock failed", isSuccess(result));
|
|
|
|
long retrieved = getLong(sizeSeg);
|
|
assertEquals("User block size should match", userblock_size, retrieved);
|
|
|
|
hdf5_h.H5Pclose(fcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_sizes()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("H5Pcreate fcpl failed", isValidId(fcpl));
|
|
|
|
// Set sizes (sizeof_addr=8, sizeof_size=8 for 64-bit addressing)
|
|
long sizeof_addr = 8;
|
|
long sizeof_size = 8;
|
|
int result = hdf5_h.H5Pset_sizes(fcpl, sizeof_addr, sizeof_size);
|
|
assertTrue("H5Pset_sizes failed", isSuccess(result));
|
|
|
|
// Get sizes back
|
|
MemorySegment addrSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
MemorySegment sizeSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
result = hdf5_h.H5Pget_sizes(fcpl, addrSeg, sizeSeg);
|
|
assertTrue("H5Pget_sizes failed", isSuccess(result));
|
|
|
|
long addr_retrieved = getLong(addrSeg);
|
|
long size_retrieved = getLong(sizeSeg);
|
|
assertEquals("Address size should match", sizeof_addr, addr_retrieved);
|
|
assertEquals("Size size should match", sizeof_size, size_retrieved);
|
|
|
|
hdf5_h.H5Pclose(fcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_sym_k()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("H5Pcreate fcpl failed", isValidId(fcpl));
|
|
|
|
// Set symbol table parameters (ik=tree rank, lk=node size)
|
|
int ik = 32;
|
|
int lk = 16;
|
|
int result = hdf5_h.H5Pset_sym_k(fcpl, ik, lk);
|
|
assertTrue("H5Pset_sym_k failed", isSuccess(result));
|
|
|
|
// Get parameters back
|
|
MemorySegment ikSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
MemorySegment lkSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
result = hdf5_h.H5Pget_sym_k(fcpl, ikSeg, lkSeg);
|
|
assertTrue("H5Pget_sym_k failed", isSuccess(result));
|
|
|
|
int ik_retrieved = getInt(ikSeg);
|
|
int lk_retrieved = getInt(lkSeg);
|
|
assertEquals("ik parameter should match", ik, ik_retrieved);
|
|
assertEquals("lk parameter should match", lk, lk_retrieved);
|
|
|
|
hdf5_h.H5Pclose(fcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_istore_k()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("H5Pcreate fcpl failed", isValidId(fcpl));
|
|
|
|
// Set indexed storage B-tree parameter
|
|
int ik = 64;
|
|
int result = hdf5_h.H5Pset_istore_k(fcpl, ik);
|
|
assertTrue("H5Pset_istore_k failed", isSuccess(result));
|
|
|
|
// Get parameter back
|
|
MemorySegment ikSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
result = hdf5_h.H5Pget_istore_k(fcpl, ikSeg);
|
|
assertTrue("H5Pget_istore_k failed", isSuccess(result));
|
|
|
|
int ik_retrieved = getInt(ikSeg);
|
|
assertEquals("istore_k parameter should match", ik, ik_retrieved);
|
|
|
|
hdf5_h.H5Pclose(fcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_shared_mesg_nindexes()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("H5Pcreate fcpl failed", isValidId(fcpl));
|
|
|
|
// Set number of shared object header message indexes
|
|
int nindexes = 3;
|
|
int result = hdf5_h.H5Pset_shared_mesg_nindexes(fcpl, nindexes);
|
|
assertTrue("H5Pset_shared_mesg_nindexes failed", isSuccess(result));
|
|
|
|
// Get number back
|
|
MemorySegment nindexSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
result = hdf5_h.H5Pget_shared_mesg_nindexes(fcpl, nindexSeg);
|
|
assertTrue("H5Pget_shared_mesg_nindexes failed", isSuccess(result));
|
|
|
|
int nindexes_retrieved = getInt(nindexSeg);
|
|
assertEquals("Number of indexes should match", nindexes, nindexes_retrieved);
|
|
|
|
hdf5_h.H5Pclose(fcpl);
|
|
}
|
|
}
|
|
|
|
// =========================
|
|
// File Access Property Tests
|
|
// =========================
|
|
|
|
@Test
|
|
public void testH5Pset_fclose_degree()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set file close degree to STRONG (close all objects when file closes)
|
|
int degree = hdf5_h.H5F_CLOSE_STRONG();
|
|
int result = hdf5_h.H5Pset_fclose_degree(fapl, degree);
|
|
assertTrue("H5Pset_fclose_degree failed", isSuccess(result));
|
|
|
|
// Get degree back
|
|
MemorySegment degreeSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
result = hdf5_h.H5Pget_fclose_degree(fapl, degreeSeg);
|
|
assertTrue("H5Pget_fclose_degree failed", isSuccess(result));
|
|
|
|
int degree_retrieved = getInt(degreeSeg);
|
|
assertEquals("File close degree should match", degree, degree_retrieved);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_alignment()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set alignment (threshold=1024, alignment=512)
|
|
long threshold = 1024;
|
|
long alignment = 512;
|
|
int result = hdf5_h.H5Pset_alignment(fapl, threshold, alignment);
|
|
assertTrue("H5Pset_alignment failed", isSuccess(result));
|
|
|
|
// Get alignment back
|
|
MemorySegment threshSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
MemorySegment alignSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
result = hdf5_h.H5Pget_alignment(fapl, threshSeg, alignSeg);
|
|
assertTrue("H5Pget_alignment failed", isSuccess(result));
|
|
|
|
long threshold_retrieved = getLong(threshSeg);
|
|
long alignment_retrieved = getLong(alignSeg);
|
|
assertEquals("Threshold should match", threshold, threshold_retrieved);
|
|
assertEquals("Alignment should match", alignment, alignment_retrieved);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_cache()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set cache parameters
|
|
int mdc_nelmts = 0; // Not used, set to 0
|
|
long rdcc_nslots = 521;
|
|
long rdcc_nbytes = 1048576;
|
|
double rdcc_w0 = 0.75;
|
|
int result = hdf5_h.H5Pset_cache(fapl, mdc_nelmts, rdcc_nslots, rdcc_nbytes, rdcc_w0);
|
|
assertTrue("H5Pset_cache failed", isSuccess(result));
|
|
|
|
// Get cache parameters back
|
|
MemorySegment mdcSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
MemorySegment nslotSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
MemorySegment nbyteSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
MemorySegment w0Seg = arena.allocate(ValueLayout.JAVA_DOUBLE);
|
|
result = hdf5_h.H5Pget_cache(fapl, mdcSeg, nslotSeg, nbyteSeg, w0Seg);
|
|
assertTrue("H5Pget_cache failed", isSuccess(result));
|
|
|
|
long nslots_retrieved = getLong(nslotSeg);
|
|
long nbytes_retrieved = getLong(nbyteSeg);
|
|
double w0_retrieved = getDouble(w0Seg);
|
|
assertEquals("rdcc_nslots should match", rdcc_nslots, nslots_retrieved);
|
|
assertEquals("rdcc_nbytes should match", rdcc_nbytes, nbytes_retrieved);
|
|
assertEquals("rdcc_w0 should match", rdcc_w0, w0_retrieved, 0.001);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_sieve_buf_size()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set data sieve buffer size
|
|
long size = 262144; // 256KB
|
|
int result = hdf5_h.H5Pset_sieve_buf_size(fapl, size);
|
|
assertTrue("H5Pset_sieve_buf_size failed", isSuccess(result));
|
|
|
|
// Get size back
|
|
MemorySegment sizeSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
result = hdf5_h.H5Pget_sieve_buf_size(fapl, sizeSeg);
|
|
assertTrue("H5Pget_sieve_buf_size failed", isSuccess(result));
|
|
|
|
long size_retrieved = getLong(sizeSeg);
|
|
assertEquals("Sieve buffer size should match", size, size_retrieved);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_meta_block_size()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set metadata block size
|
|
long size = 8192;
|
|
int result = hdf5_h.H5Pset_meta_block_size(fapl, size);
|
|
assertTrue("H5Pset_meta_block_size failed", isSuccess(result));
|
|
|
|
// Get size back
|
|
MemorySegment sizeSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
result = hdf5_h.H5Pget_meta_block_size(fapl, sizeSeg);
|
|
assertTrue("H5Pget_meta_block_size failed", isSuccess(result));
|
|
|
|
long size_retrieved = getLong(sizeSeg);
|
|
assertEquals("Meta block size should match", size, size_retrieved);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
// ================================================================================
|
|
// Phase 6B - Dataset Creation Properties
|
|
// ================================================================================
|
|
|
|
@Test
|
|
public void testH5Pset_chunk()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Set chunk dimensions: 10x20
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkDimsSegment = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkDimsSegment, chunkDims);
|
|
|
|
int result = hdf5_h.H5Pset_chunk(dcpl, 2, chunkDimsSegment);
|
|
assertTrue("H5Pset_chunk failed", isSuccess(result));
|
|
|
|
// Get chunk dimensions back
|
|
MemorySegment outChunkSegment = allocateLongArray(arena, 2);
|
|
int ndims = hdf5_h.H5Pget_chunk(dcpl, 2, outChunkSegment);
|
|
assertEquals("Should have 2 dimensions", 2, ndims);
|
|
|
|
long[] retrieved = new long[2];
|
|
copyFromSegment(outChunkSegment, retrieved);
|
|
assertArrayEquals("Chunk dimensions should match", chunkDims, retrieved);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_layout()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Set layout to compact
|
|
int result = hdf5_h.H5Pset_layout(dcpl, hdf5_h.H5D_COMPACT());
|
|
assertTrue("H5Pset_layout failed", isSuccess(result));
|
|
|
|
// Get layout back
|
|
int layout = hdf5_h.H5Pget_layout(dcpl);
|
|
assertEquals("Layout should be H5D_COMPACT", hdf5_h.H5D_COMPACT(), layout);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_fill_value()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Set fill value to 42
|
|
int fillValue = 42;
|
|
MemorySegment fillSegment = allocateInt(arena);
|
|
setInt(fillSegment, fillValue);
|
|
|
|
int result = hdf5_h.H5Pset_fill_value(dcpl, hdf5_h.H5T_NATIVE_INT_g(), fillSegment);
|
|
assertTrue("H5Pset_fill_value failed", isSuccess(result));
|
|
|
|
// Get fill value back
|
|
MemorySegment outFillSegment = allocateInt(arena);
|
|
result = hdf5_h.H5Pget_fill_value(dcpl, hdf5_h.H5T_NATIVE_INT_g(), outFillSegment);
|
|
assertTrue("H5Pget_fill_value failed", isSuccess(result));
|
|
|
|
int retrieved = getInt(outFillSegment);
|
|
assertEquals("Fill value should match", fillValue, retrieved);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_fill_time()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Set fill time to ALLOC (fill on allocation)
|
|
int result = hdf5_h.H5Pset_fill_time(dcpl, hdf5_h.H5D_FILL_TIME_ALLOC());
|
|
assertTrue("H5Pset_fill_time failed", isSuccess(result));
|
|
|
|
// Get fill time back
|
|
MemorySegment fillTimeSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
result = hdf5_h.H5Pget_fill_time(dcpl, fillTimeSeg);
|
|
assertTrue("H5Pget_fill_time failed", isSuccess(result));
|
|
|
|
int fillTime = getInt(fillTimeSeg);
|
|
assertEquals("Fill time should be H5D_FILL_TIME_ALLOC", hdf5_h.H5D_FILL_TIME_ALLOC(), fillTime);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_alloc_time()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Set allocation time to EARLY (allocate on creation)
|
|
int result = hdf5_h.H5Pset_alloc_time(dcpl, hdf5_h.H5D_ALLOC_TIME_EARLY());
|
|
assertTrue("H5Pset_alloc_time failed", isSuccess(result));
|
|
|
|
// Get allocation time back
|
|
MemorySegment allocTimeSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
result = hdf5_h.H5Pget_alloc_time(dcpl, allocTimeSeg);
|
|
assertTrue("H5Pget_alloc_time failed", isSuccess(result));
|
|
|
|
int allocTime = getInt(allocTimeSeg);
|
|
assertEquals("Allocation time should be H5D_ALLOC_TIME_EARLY", hdf5_h.H5D_ALLOC_TIME_EARLY(),
|
|
allocTime);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
// ================================================================================
|
|
// Phase 6C - Compression and Filters
|
|
// ================================================================================
|
|
|
|
@Test
|
|
public void testH5Pset_deflate()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Must set chunk first for compression
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkDimsSegment = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkDimsSegment, chunkDims);
|
|
int result = hdf5_h.H5Pset_chunk(dcpl, 2, chunkDimsSegment);
|
|
assertTrue("H5Pset_chunk failed", isSuccess(result));
|
|
|
|
// Set deflate compression (gzip) with level 6
|
|
int compressionLevel = 6;
|
|
result = hdf5_h.H5Pset_deflate(dcpl, compressionLevel);
|
|
assertTrue("H5Pset_deflate failed", isSuccess(result));
|
|
|
|
// Get number of filters
|
|
int nfilters = hdf5_h.H5Pget_nfilters(dcpl);
|
|
assertEquals("Should have 1 filter", 1, nfilters);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_nfilters()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Initially no filters
|
|
int nfilters = hdf5_h.H5Pget_nfilters(dcpl);
|
|
assertEquals("Should have 0 filters initially", 0, nfilters);
|
|
|
|
// Add chunk (required for filters)
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkDimsSegment = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkDimsSegment, chunkDims);
|
|
hdf5_h.H5Pset_chunk(dcpl, 2, chunkDimsSegment);
|
|
|
|
// Add deflate filter
|
|
hdf5_h.H5Pset_deflate(dcpl, 6);
|
|
|
|
// Now should have 1 filter
|
|
nfilters = hdf5_h.H5Pget_nfilters(dcpl);
|
|
assertEquals("Should have 1 filter after adding deflate", 1, nfilters);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pall_filters_avail()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Add chunk (required for filters)
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkDimsSegment = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkDimsSegment, chunkDims);
|
|
hdf5_h.H5Pset_chunk(dcpl, 2, chunkDimsSegment);
|
|
|
|
// Add deflate filter (should be available in standard builds)
|
|
hdf5_h.H5Pset_deflate(dcpl, 6);
|
|
|
|
// Check if all filters are available
|
|
int avail = hdf5_h.H5Pall_filters_avail(dcpl);
|
|
// Note: Result depends on HDF5 build configuration
|
|
// Just verify the function works (returns 0 or 1)
|
|
assertTrue("H5Pall_filters_avail should return valid result", avail == 0 || avail > 0);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_shuffle()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Add chunk (required for filters)
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkDimsSegment = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkDimsSegment, chunkDims);
|
|
hdf5_h.H5Pset_chunk(dcpl, 2, chunkDimsSegment);
|
|
|
|
// Set shuffle filter (improves compression)
|
|
int result = hdf5_h.H5Pset_shuffle(dcpl);
|
|
assertTrue("H5Pset_shuffle failed", isSuccess(result));
|
|
|
|
// Verify filter was added
|
|
int nfilters = hdf5_h.H5Pget_nfilters(dcpl);
|
|
assertEquals("Should have 1 filter", 1, nfilters);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_fletcher32()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Add chunk (required for filters)
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkDimsSegment = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkDimsSegment, chunkDims);
|
|
hdf5_h.H5Pset_chunk(dcpl, 2, chunkDimsSegment);
|
|
|
|
// Set Fletcher32 checksum filter (error detection)
|
|
int result = hdf5_h.H5Pset_fletcher32(dcpl);
|
|
assertTrue("H5Pset_fletcher32 failed", isSuccess(result));
|
|
|
|
// Verify filter was added
|
|
int nfilters = hdf5_h.H5Pget_nfilters(dcpl);
|
|
assertEquals("Should have 1 filter", 1, nfilters);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
// ================================================================================
|
|
// Phase 6D - Data Transfer and Advanced Properties
|
|
// ================================================================================
|
|
|
|
// Note: H5Pget_filter might not be available in FFM bindings yet
|
|
// Skipping this test until API is available
|
|
/*
|
|
@Test
|
|
public void testH5Pget_filter()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Must set chunk first
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkDimsSegment = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkDimsSegment, chunkDims);
|
|
int result = hdf5_h.H5Pset_chunk(dcpl, 2, chunkDimsSegment);
|
|
assertTrue("H5Pset_chunk failed", isSuccess(result));
|
|
|
|
// Add deflate filter
|
|
int compressionLevel = 6;
|
|
result = hdf5_h.H5Pset_deflate(dcpl, compressionLevel);
|
|
assertTrue("H5Pset_deflate failed", isSuccess(result));
|
|
|
|
// Get filter information
|
|
MemorySegment flags = allocateIntArray(arena, 1);
|
|
MemorySegment cdNelts = allocateLongArray(arena, 1);
|
|
MemorySegment cdValues = allocateIntArray(arena, 10); // Space for filter params
|
|
MemorySegment nameSegment = arena.allocate(256);
|
|
MemorySegment filterConfig = allocateIntArray(arena, 1);
|
|
|
|
// Set initial cd_nelmts to max size
|
|
copyToSegment(cdNelts, new long[]{10});
|
|
|
|
int filterId = hdf5_h.H5Pget_filter(dcpl, 0, flags, cdNelts, cdValues,
|
|
256, nameSegment, filterConfig);
|
|
assertTrue("H5Pget_filter should return valid filter ID", filterId >= 0);
|
|
|
|
// Verify it's the deflate filter
|
|
assertEquals("Should be deflate filter", hdf5_h.H5Z_FILTER_DEFLATE(), filterId);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
*/
|
|
|
|
@Test
|
|
public void testH5Premove_filter()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Must set chunk first
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkDimsSegment = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkDimsSegment, chunkDims);
|
|
int result = hdf5_h.H5Pset_chunk(dcpl, 2, chunkDimsSegment);
|
|
assertTrue("H5Pset_chunk failed", isSuccess(result));
|
|
|
|
// Add deflate filter
|
|
result = hdf5_h.H5Pset_deflate(dcpl, 6);
|
|
assertTrue("H5Pset_deflate failed", isSuccess(result));
|
|
|
|
// Verify filter was added
|
|
int nfilters = hdf5_h.H5Pget_nfilters(dcpl);
|
|
assertEquals("Should have 1 filter", 1, nfilters);
|
|
|
|
// Remove the deflate filter
|
|
result = hdf5_h.H5Premove_filter(dcpl, hdf5_h.H5Z_FILTER_DEFLATE());
|
|
assertTrue("H5Premove_filter failed", isSuccess(result));
|
|
|
|
// Verify filter was removed
|
|
nfilters = hdf5_h.H5Pget_nfilters(dcpl);
|
|
assertEquals("Should have 0 filters after removal", 0, nfilters);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_chunk_cache()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate dapl failed", isValidId(dapl));
|
|
|
|
// Set chunk cache parameters
|
|
long rdccNslots = 521; // Number of chunk slots in cache
|
|
long rdccNbytes = 1048576; // Size of chunk cache in bytes (1 MB)
|
|
double rdccW0 = 0.75; // Preemption policy
|
|
|
|
int result = hdf5_h.H5Pset_chunk_cache(dapl, rdccNslots, rdccNbytes, rdccW0);
|
|
assertTrue("H5Pset_chunk_cache failed", isSuccess(result));
|
|
|
|
// Get chunk cache parameters back
|
|
MemorySegment outNslots = allocateLongArray(arena, 1);
|
|
MemorySegment outNbytes = allocateLongArray(arena, 1);
|
|
MemorySegment outW0 = allocateDoubleArray(arena, 1);
|
|
|
|
result = hdf5_h.H5Pget_chunk_cache(dapl, outNslots, outNbytes, outW0);
|
|
assertTrue("H5Pget_chunk_cache failed", isSuccess(result));
|
|
|
|
// Verify values
|
|
assertEquals("Nslots should match", rdccNslots, getLong(outNslots));
|
|
assertEquals("Nbytes should match", rdccNbytes, getLong(outNbytes));
|
|
assertEquals("W0 should match", rdccW0, getDouble(outW0), 0.01);
|
|
|
|
hdf5_h.H5Pclose(dapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_hyper_vector_size()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dxpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_XFER_ID_g());
|
|
assertTrue("H5Pcreate dxpl failed", isValidId(dxpl));
|
|
|
|
// Set hyperslab vector size
|
|
long vectorSize = 1024;
|
|
int result = hdf5_h.H5Pset_hyper_vector_size(dxpl, vectorSize);
|
|
assertTrue("H5Pset_hyper_vector_size failed", isSuccess(result));
|
|
|
|
// Get vector size back
|
|
MemorySegment outSize = allocateLongArray(arena, 1);
|
|
result = hdf5_h.H5Pget_hyper_vector_size(dxpl, outSize);
|
|
assertTrue("H5Pget_hyper_vector_size failed", isSuccess(result));
|
|
|
|
assertEquals("Vector size should match", vectorSize, getLong(outSize));
|
|
|
|
hdf5_h.H5Pclose(dxpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_btree_ratios()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dxpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_XFER_ID_g());
|
|
assertTrue("H5Pcreate dxpl failed", isValidId(dxpl));
|
|
|
|
// Set B-tree split ratios
|
|
double left = 0.1;
|
|
double middle = 0.5;
|
|
double right = 0.9;
|
|
|
|
int result = hdf5_h.H5Pset_btree_ratios(dxpl, left, middle, right);
|
|
assertTrue("H5Pset_btree_ratios failed", isSuccess(result));
|
|
|
|
// Get ratios back
|
|
MemorySegment outLeft = allocateDoubleArray(arena, 1);
|
|
MemorySegment outMiddle = allocateDoubleArray(arena, 1);
|
|
MemorySegment outRight = allocateDoubleArray(arena, 1);
|
|
|
|
result = hdf5_h.H5Pget_btree_ratios(dxpl, outLeft, outMiddle, outRight);
|
|
assertTrue("H5Pget_btree_ratios failed", isSuccess(result));
|
|
|
|
assertEquals("Left ratio should match", left, getDouble(outLeft), 0.01);
|
|
assertEquals("Middle ratio should match", middle, getDouble(outMiddle), 0.01);
|
|
assertEquals("Right ratio should match", right, getDouble(outRight), 0.01);
|
|
|
|
hdf5_h.H5Pclose(dxpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_edc_check()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dxpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_XFER_ID_g());
|
|
assertTrue("H5Pcreate dxpl failed", isValidId(dxpl));
|
|
|
|
// Enable error detection (EDC)
|
|
int result = hdf5_h.H5Pset_edc_check(dxpl, hdf5_h.H5Z_ENABLE_EDC());
|
|
assertTrue("H5Pset_edc_check failed", isSuccess(result));
|
|
|
|
// Get EDC check setting
|
|
int edcCheck = hdf5_h.H5Pget_edc_check(dxpl);
|
|
assertEquals("EDC check should be enabled", hdf5_h.H5Z_ENABLE_EDC(), edcCheck);
|
|
|
|
// Disable error detection
|
|
result = hdf5_h.H5Pset_edc_check(dxpl, hdf5_h.H5Z_DISABLE_EDC());
|
|
assertTrue("H5Pset_edc_check (disable) failed", isSuccess(result));
|
|
|
|
edcCheck = hdf5_h.H5Pget_edc_check(dxpl);
|
|
assertEquals("EDC check should be disabled", hdf5_h.H5Z_DISABLE_EDC(), edcCheck);
|
|
|
|
hdf5_h.H5Pclose(dxpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_buffer()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dxpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_XFER_ID_g());
|
|
assertTrue("H5Pcreate dxpl failed", isValidId(dxpl));
|
|
|
|
// Set type conversion buffer size (1 MB)
|
|
long bufferSize = 1048576;
|
|
int result = hdf5_h.H5Pset_buffer(dxpl, bufferSize, MemorySegment.NULL, MemorySegment.NULL);
|
|
assertTrue("H5Pset_buffer failed", isSuccess(result));
|
|
|
|
// Get buffer size back
|
|
long retrievedSize = hdf5_h.H5Pget_buffer(dxpl, MemorySegment.NULL, MemorySegment.NULL);
|
|
assertEquals("Buffer size should match", bufferSize, retrievedSize);
|
|
|
|
hdf5_h.H5Pclose(dxpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_libver_bounds()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set library version bounds to latest
|
|
int result =
|
|
hdf5_h.H5Pset_libver_bounds(fapl, hdf5_h.H5F_LIBVER_LATEST(), hdf5_h.H5F_LIBVER_LATEST());
|
|
assertTrue("H5Pset_libver_bounds failed", isSuccess(result));
|
|
|
|
// Get library version bounds back
|
|
MemorySegment low = allocateIntArray(arena, 1);
|
|
MemorySegment high = allocateIntArray(arena, 1);
|
|
|
|
result = hdf5_h.H5Pget_libver_bounds(fapl, low, high);
|
|
assertTrue("H5Pget_libver_bounds failed", isSuccess(result));
|
|
|
|
assertEquals("Low bound should be latest", hdf5_h.H5F_LIBVER_LATEST(), getInt(low));
|
|
assertEquals("High bound should be latest", hdf5_h.H5F_LIBVER_LATEST(), getInt(high));
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_small_data_block_size()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set small data block size (2048 bytes)
|
|
long blockSize = 2048;
|
|
int result = hdf5_h.H5Pset_small_data_block_size(fapl, blockSize);
|
|
assertTrue("H5Pset_small_data_block_size failed", isSuccess(result));
|
|
|
|
// Get block size back
|
|
MemorySegment outSize = allocateLongArray(arena, 1);
|
|
result = hdf5_h.H5Pget_small_data_block_size(fapl, outSize);
|
|
assertTrue("H5Pget_small_data_block_size failed", isSuccess(result));
|
|
|
|
assertEquals("Block size should match", blockSize, getLong(outSize));
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_gc_references()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Enable garbage collection for references
|
|
int result = hdf5_h.H5Pset_gc_references(fapl, 1);
|
|
assertTrue("H5Pset_gc_references failed", isSuccess(result));
|
|
|
|
// Get GC references setting
|
|
MemorySegment gcRefs = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_gc_references(fapl, gcRefs);
|
|
assertTrue("H5Pget_gc_references failed", isSuccess(result));
|
|
|
|
assertEquals("GC references should be enabled", 1, getInt(gcRefs));
|
|
|
|
// Disable garbage collection
|
|
result = hdf5_h.H5Pset_gc_references(fapl, 0);
|
|
assertTrue("H5Pset_gc_references (disable) failed", isSuccess(result));
|
|
|
|
result = hdf5_h.H5Pget_gc_references(fapl, gcRefs);
|
|
assertTrue("H5Pget_gc_references (after disable) failed", isSuccess(result));
|
|
|
|
assertEquals("GC references should be disabled", 0, getInt(gcRefs));
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
// ================================================================================
|
|
// Phase 6E - Link, Attribute, and Advanced Properties
|
|
// ================================================================================
|
|
|
|
@Test
|
|
public void testH5Pset_create_intermediate_group()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long lcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_LINK_CREATE_ID_g());
|
|
assertTrue("H5Pcreate lcpl failed", isValidId(lcpl));
|
|
|
|
// Enable intermediate group creation
|
|
int result = hdf5_h.H5Pset_create_intermediate_group(lcpl, 1);
|
|
assertTrue("H5Pset_create_intermediate_group failed", isSuccess(result));
|
|
|
|
// Get setting back
|
|
MemorySegment crtIntmd = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_create_intermediate_group(lcpl, crtIntmd);
|
|
assertTrue("H5Pget_create_intermediate_group failed", isSuccess(result));
|
|
|
|
assertEquals("Create intermediate should be enabled", 1, getInt(crtIntmd));
|
|
|
|
hdf5_h.H5Pclose(lcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_char_encoding()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long lcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_LINK_CREATE_ID_g());
|
|
assertTrue("H5Pcreate lcpl failed", isValidId(lcpl));
|
|
|
|
// Set character encoding to UTF-8
|
|
int result = hdf5_h.H5Pset_char_encoding(lcpl, hdf5_h.H5T_CSET_UTF8());
|
|
assertTrue("H5Pset_char_encoding failed", isSuccess(result));
|
|
|
|
// Get encoding back
|
|
MemorySegment encoding = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_char_encoding(lcpl, encoding);
|
|
assertTrue("H5Pget_char_encoding failed", isSuccess(result));
|
|
|
|
assertEquals("Encoding should be UTF-8", hdf5_h.H5T_CSET_UTF8(), getInt(encoding));
|
|
|
|
hdf5_h.H5Pclose(lcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_attr_creation_order()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long ocpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_OBJECT_CREATE_ID_g());
|
|
assertTrue("H5Pcreate ocpl failed", isValidId(ocpl));
|
|
|
|
// Set attribute creation order tracking and indexing
|
|
int crtOrderFlags = hdf5_h.H5P_CRT_ORDER_TRACKED() | hdf5_h.H5P_CRT_ORDER_INDEXED();
|
|
int result = hdf5_h.H5Pset_attr_creation_order(ocpl, crtOrderFlags);
|
|
assertTrue("H5Pset_attr_creation_order failed", isSuccess(result));
|
|
|
|
// Get flags back
|
|
MemorySegment flags = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_attr_creation_order(ocpl, flags);
|
|
assertTrue("H5Pget_attr_creation_order failed", isSuccess(result));
|
|
|
|
assertEquals("Attr creation order flags should match", crtOrderFlags, getInt(flags));
|
|
|
|
hdf5_h.H5Pclose(ocpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_nlinks()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long lapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_LINK_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate lapl failed", isValidId(lapl));
|
|
|
|
// Set maximum number of soft/external link traversals
|
|
long nlinks = 100;
|
|
int result = hdf5_h.H5Pset_nlinks(lapl, nlinks);
|
|
assertTrue("H5Pset_nlinks failed", isSuccess(result));
|
|
|
|
// Get nlinks back
|
|
MemorySegment outNlinks = allocateLongArray(arena, 1);
|
|
result = hdf5_h.H5Pget_nlinks(lapl, outNlinks);
|
|
assertTrue("H5Pget_nlinks failed", isSuccess(result));
|
|
|
|
assertEquals("Nlinks should match", nlinks, getLong(outNlinks));
|
|
|
|
hdf5_h.H5Pclose(lapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_efile_prefix()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate dapl failed", isValidId(dapl));
|
|
|
|
// Set external file prefix
|
|
String prefix = "/tmp/external";
|
|
MemorySegment prefixSeg = stringToSegment(arena, prefix);
|
|
int result = hdf5_h.H5Pset_efile_prefix(dapl, prefixSeg);
|
|
assertTrue("H5Pset_efile_prefix failed", isSuccess(result));
|
|
|
|
// Get prefix back
|
|
long prefixSize = hdf5_h.H5Pget_efile_prefix(dapl, MemorySegment.NULL, 0);
|
|
assertTrue("H5Pget_efile_prefix size query failed", prefixSize > 0);
|
|
|
|
MemorySegment prefixBuf = arena.allocate(prefixSize + 1);
|
|
result = (int)hdf5_h.H5Pget_efile_prefix(dapl, prefixBuf, prefixSize + 1);
|
|
assertTrue("H5Pget_efile_prefix failed", result >= 0);
|
|
|
|
String retrievedPrefix = segmentToString(prefixBuf);
|
|
assertEquals("Prefix should match", prefix, retrievedPrefix);
|
|
|
|
hdf5_h.H5Pclose(dapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_chunk_opts()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Must set chunking first
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkDimsSegment = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkDimsSegment, chunkDims);
|
|
hdf5_h.H5Pset_chunk(dcpl, 2, chunkDimsSegment);
|
|
|
|
// Set chunk optimization options (don't filter partial edge chunks)
|
|
int opts = hdf5_h.H5D_CHUNK_DONT_FILTER_PARTIAL_CHUNKS();
|
|
int result = hdf5_h.H5Pset_chunk_opts(dcpl, opts);
|
|
assertTrue("H5Pset_chunk_opts failed", isSuccess(result));
|
|
|
|
// Get options back
|
|
MemorySegment outOpts = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_chunk_opts(dcpl, outOpts);
|
|
assertTrue("H5Pget_chunk_opts failed", isSuccess(result));
|
|
|
|
assertEquals("Chunk opts should match", opts, getInt(outOpts));
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_file_space_strategy()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("H5Pcreate fcpl failed", isValidId(fcpl));
|
|
|
|
// Set file space strategy (aggregation strategy)
|
|
int strategy = hdf5_h.H5F_FSPACE_STRATEGY_FSM_AGGR(); // Free-space manager with aggregation
|
|
boolean persist = true; // Persist free-space
|
|
long threshold = 1; // Threshold
|
|
int result = hdf5_h.H5Pset_file_space_strategy(fcpl, strategy, persist, threshold);
|
|
assertTrue("H5Pset_file_space_strategy failed", isSuccess(result));
|
|
|
|
// Get strategy back
|
|
MemorySegment outStrategy = allocateIntArray(arena, 1);
|
|
MemorySegment outPersist = allocateIntArray(arena, 1);
|
|
MemorySegment outThreshold = allocateLongArray(arena, 1);
|
|
result = hdf5_h.H5Pget_file_space_strategy(fcpl, outStrategy, outPersist, outThreshold);
|
|
assertTrue("H5Pget_file_space_strategy failed", isSuccess(result));
|
|
|
|
assertEquals("Strategy should match", strategy, getInt(outStrategy));
|
|
assertEquals("Persist should be true", 1, getInt(outPersist)); // true = 1
|
|
assertEquals("Threshold should match", threshold, getLong(outThreshold));
|
|
|
|
hdf5_h.H5Pclose(fcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_file_space_page_size()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("H5Pcreate fcpl failed", isValidId(fcpl));
|
|
|
|
// Set file space page size (4KB)
|
|
long pageSize = 4096;
|
|
int result = hdf5_h.H5Pset_file_space_page_size(fcpl, pageSize);
|
|
assertTrue("H5Pset_file_space_page_size failed", isSuccess(result));
|
|
|
|
// Get page size back
|
|
MemorySegment outPageSize = allocateLongArray(arena, 1);
|
|
result = hdf5_h.H5Pget_file_space_page_size(fcpl, outPageSize);
|
|
assertTrue("H5Pget_file_space_page_size failed", isSuccess(result));
|
|
|
|
assertEquals("Page size should match", pageSize, getLong(outPageSize));
|
|
|
|
hdf5_h.H5Pclose(fcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_local_heap_size_hint()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long gcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_GROUP_CREATE_ID_g());
|
|
assertTrue("H5Pcreate gcpl failed", isValidId(gcpl));
|
|
|
|
// Set local heap size hint (1KB)
|
|
long sizeHint = 1024;
|
|
int result = hdf5_h.H5Pset_local_heap_size_hint(gcpl, sizeHint);
|
|
assertTrue("H5Pset_local_heap_size_hint failed", isSuccess(result));
|
|
|
|
// Get size hint back
|
|
MemorySegment outSizeHint = allocateLongArray(arena, 1);
|
|
result = hdf5_h.H5Pget_local_heap_size_hint(gcpl, outSizeHint);
|
|
assertTrue("H5Pget_local_heap_size_hint failed", isSuccess(result));
|
|
|
|
assertEquals("Size hint should match", sizeHint, getLong(outSizeHint));
|
|
|
|
hdf5_h.H5Pclose(gcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_shared_mesg_index()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_CREATE_ID_g());
|
|
assertTrue("H5Pcreate fcpl failed", isValidId(fcpl));
|
|
|
|
// First set number of indexes
|
|
hdf5_h.H5Pset_shared_mesg_nindexes(fcpl, 2);
|
|
|
|
// Set shared message index (index 0, dataspace + datatype messages, min size 100)
|
|
int indexNum = 0;
|
|
int mesgTypes = hdf5_h.H5O_SHMESG_SDSPACE_FLAG() | hdf5_h.H5O_SHMESG_DTYPE_FLAG();
|
|
int minSize = 100;
|
|
int result = hdf5_h.H5Pset_shared_mesg_index(fcpl, indexNum, mesgTypes, minSize);
|
|
assertTrue("H5Pset_shared_mesg_index failed", isSuccess(result));
|
|
|
|
// Get index info back
|
|
MemorySegment outMesgTypes = allocateIntArray(arena, 1);
|
|
MemorySegment outMinSize = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_shared_mesg_index(fcpl, indexNum, outMesgTypes, outMinSize);
|
|
assertTrue("H5Pget_shared_mesg_index failed", isSuccess(result));
|
|
|
|
assertEquals("Message types should match", mesgTypes, getInt(outMesgTypes));
|
|
assertEquals("Min size should match", minSize, getInt(outMinSize));
|
|
|
|
hdf5_h.H5Pclose(fcpl);
|
|
}
|
|
}
|
|
|
|
// =========================
|
|
// Additional Property List Tests for C API Coverage
|
|
// =========================
|
|
|
|
@Test
|
|
public void testH5Pset_data_transform()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dxpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_XFER_ID_g());
|
|
assertTrue("H5Pcreate dxpl failed", isValidId(dxpl));
|
|
|
|
// Set a data transform expression (multiply by 2)
|
|
String transform = "x*2";
|
|
MemorySegment transformSeg = stringToSegment(arena, transform);
|
|
int result = hdf5_h.H5Pset_data_transform(dxpl, transformSeg);
|
|
assertTrue("H5Pset_data_transform failed", isSuccess(result));
|
|
|
|
// Get size of transform expression
|
|
long transformSize = hdf5_h.H5Pget_data_transform(dxpl, MemorySegment.NULL, 0);
|
|
assertTrue("H5Pget_data_transform size query failed", transformSize > 0);
|
|
|
|
// Get transform expression back
|
|
MemorySegment outTransform = arena.allocate(transformSize + 1);
|
|
long actualSize = hdf5_h.H5Pget_data_transform(dxpl, outTransform, transformSize + 1);
|
|
assertTrue("H5Pget_data_transform failed", actualSize > 0);
|
|
|
|
String retrievedTransform = segmentToString(outTransform);
|
|
assertEquals("Transform should match", transform, retrievedTransform);
|
|
|
|
hdf5_h.H5Pclose(dxpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_copy_object()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long ocpypl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_OBJECT_COPY_ID_g());
|
|
assertTrue("H5Pcreate ocpypl failed", isValidId(ocpypl));
|
|
|
|
// Set copy object flags (shallow hierarchy copy, copy without attributes)
|
|
int copyFlags = hdf5_h.H5O_COPY_SHALLOW_HIERARCHY_FLAG() | hdf5_h.H5O_COPY_WITHOUT_ATTR_FLAG();
|
|
int result = hdf5_h.H5Pset_copy_object(ocpypl, copyFlags);
|
|
assertTrue("H5Pset_copy_object failed", isSuccess(result));
|
|
|
|
// Get copy object flags back
|
|
MemorySegment outFlags = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_copy_object(ocpypl, outFlags);
|
|
assertTrue("H5Pget_copy_object failed", isSuccess(result));
|
|
|
|
assertEquals("Copy flags should match", copyFlags, getInt(outFlags));
|
|
|
|
hdf5_h.H5Pclose(ocpypl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_filter_by_id()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Set chunking (required for filters)
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkSeg = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkSeg, chunkDims);
|
|
hdf5_h.H5Pset_chunk(dcpl, 2, chunkSeg);
|
|
|
|
// Add deflate filter with compression level 6
|
|
hdf5_h.H5Pset_deflate(dcpl, 6);
|
|
|
|
// Query the deflate filter by ID
|
|
int filterId = hdf5_h.H5Z_FILTER_DEFLATE();
|
|
MemorySegment flags = allocateIntArray(arena, 1);
|
|
MemorySegment nElements = allocateLongArray(arena, 1);
|
|
nElements.set(ValueLayout.JAVA_LONG, 0, 8); // Max 8 cd_values
|
|
MemorySegment cdValues = allocateIntArray(arena, 8);
|
|
long nameSize = 256;
|
|
MemorySegment filterName = arena.allocate(nameSize);
|
|
MemorySegment filterConfig = allocateIntArray(arena, 1);
|
|
|
|
int result = hdf5_h.H5Pget_filter_by_id2(dcpl, filterId, flags, nElements, cdValues, nameSize,
|
|
filterName, filterConfig);
|
|
assertTrue("H5Pget_filter_by_id2 failed", isSuccess(result));
|
|
|
|
// Verify deflate was found
|
|
long actualNElements = nElements.get(ValueLayout.JAVA_LONG, 0);
|
|
assertTrue("Should have cd_values for deflate", actualNElements > 0);
|
|
|
|
// First cd_value should be compression level (6)
|
|
int compressionLevel = cdValues.get(ValueLayout.JAVA_INT, 0);
|
|
assertEquals("Compression level should be 6", 6, compressionLevel);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_chunk_cache()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate dapl failed", isValidId(dapl));
|
|
|
|
// Set chunk cache parameters
|
|
long rdccNslots = 521; // Number of chunk slots in cache
|
|
long rdccNbytes = 1048576; // Size of chunk cache in bytes (1 MB)
|
|
double rdccW0 = 0.75; // Preemption policy
|
|
|
|
int result = hdf5_h.H5Pset_chunk_cache(dapl, rdccNslots, rdccNbytes, rdccW0);
|
|
assertTrue("H5Pset_chunk_cache failed", isSuccess(result));
|
|
|
|
// Get chunk cache parameters back
|
|
MemorySegment outNslots = allocateLongArray(arena, 1);
|
|
MemorySegment outNbytes = allocateLongArray(arena, 1);
|
|
MemorySegment outW0 = allocateDoubleArray(arena, 1);
|
|
|
|
result = hdf5_h.H5Pget_chunk_cache(dapl, outNslots, outNbytes, outW0);
|
|
assertTrue("H5Pget_chunk_cache failed", isSuccess(result));
|
|
|
|
assertEquals("Nslots should match", rdccNslots, getLong(outNslots));
|
|
assertEquals("Nbytes should match", rdccNbytes, getLong(outNbytes));
|
|
assertEquals("W0 should match", rdccW0, getDouble(outW0), 0.001);
|
|
|
|
hdf5_h.H5Pclose(dapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pmodify_filter()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Set chunking (required for filters)
|
|
long[] chunkDims = {10, 20};
|
|
MemorySegment chunkSeg = allocateLongArray(arena, 2);
|
|
copyToSegment(chunkSeg, chunkDims);
|
|
hdf5_h.H5Pset_chunk(dcpl, 2, chunkSeg);
|
|
|
|
// Add deflate filter with compression level 6
|
|
hdf5_h.H5Pset_deflate(dcpl, 6);
|
|
|
|
// Modify deflate filter to use compression level 9
|
|
int filterId = hdf5_h.H5Z_FILTER_DEFLATE();
|
|
int flags = 0; // Mandatory filter
|
|
long nElements = 1; // One cd_value (compression level)
|
|
MemorySegment cdValues = allocateIntArray(arena, 1);
|
|
cdValues.set(ValueLayout.JAVA_INT, 0, 9); // Level 9
|
|
|
|
int result = hdf5_h.H5Pmodify_filter(dcpl, filterId, flags, nElements, cdValues);
|
|
assertTrue("H5Pmodify_filter failed", isSuccess(result));
|
|
|
|
// Verify the filter was modified
|
|
MemorySegment outFlags = allocateIntArray(arena, 1);
|
|
MemorySegment outNElements = allocateLongArray(arena, 1);
|
|
outNElements.set(ValueLayout.JAVA_LONG, 0, 8);
|
|
MemorySegment outCdValues = allocateIntArray(arena, 8);
|
|
MemorySegment outName = arena.allocate(256);
|
|
MemorySegment outConfig = allocateIntArray(arena, 1);
|
|
|
|
result = hdf5_h.H5Pget_filter_by_id2(dcpl, filterId, outFlags, outNElements, outCdValues, 256,
|
|
outName, outConfig);
|
|
assertTrue("H5Pget_filter_by_id2 failed", isSuccess(result));
|
|
|
|
// Verify compression level is now 9
|
|
int compressionLevel = outCdValues.get(ValueLayout.JAVA_INT, 0);
|
|
assertEquals("Compression level should be 9 after modify", 9, compressionLevel);
|
|
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_fapl_core()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set core (memory) VFD with 1MB increment and backing store enabled
|
|
long increment = 1024 * 1024; // 1MB increments
|
|
boolean backingStore = true; // Enable backing store
|
|
int result = hdf5_h.H5Pset_fapl_core(fapl, increment, backingStore);
|
|
assertTrue("H5Pset_fapl_core failed", isSuccess(result));
|
|
|
|
// Get core VFD settings
|
|
MemorySegment incrementSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
MemorySegment backingStoreSeg = arena.allocate(ValueLayout.JAVA_BOOLEAN);
|
|
result = hdf5_h.H5Pget_fapl_core(fapl, incrementSeg, backingStoreSeg);
|
|
assertTrue("H5Pget_fapl_core failed", isSuccess(result));
|
|
|
|
long retIncrement = incrementSeg.get(ValueLayout.JAVA_LONG, 0);
|
|
assertEquals("Increment should match", increment, retIncrement);
|
|
|
|
boolean retBackingStore = backingStoreSeg.get(ValueLayout.JAVA_BOOLEAN, 0);
|
|
assertEquals("Backing store should match", backingStore, retBackingStore);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_fapl_log()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set log VFD with log file and flags
|
|
String logFile = "test_h5pffm.log";
|
|
long flags = hdf5_h.H5FD_LOG_LOC_IO() | hdf5_h.H5FD_LOG_ALLOC(); // Log I/O and allocation
|
|
long bufSize = 4096; // 4KB buffer
|
|
|
|
int result = hdf5_h.H5Pset_fapl_log(fapl, stringToSegment(arena, logFile), flags, bufSize);
|
|
assertTrue("H5Pset_fapl_log failed", isSuccess(result));
|
|
|
|
// Note: H5Pget_fapl_log doesn't exist, just verify VFD was set
|
|
long driverId = hdf5_h.H5Pget_driver(fapl);
|
|
assertTrue("Driver ID should be valid", isValidId(driverId));
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
|
|
// Clean up log file
|
|
_deleteFile(logFile);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_fapl_sec2()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set sec2 (standard I/O) VFD
|
|
int result = hdf5_h.H5Pset_fapl_sec2(fapl);
|
|
assertTrue("H5Pset_fapl_sec2 failed", isSuccess(result));
|
|
|
|
// Verify VFD was set
|
|
long driverId = hdf5_h.H5Pget_driver(fapl);
|
|
assertTrue("Driver ID should be valid", isValidId(driverId));
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_fapl_family()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Create member FAPL (use default)
|
|
long memberFapl = hdf5_h.H5P_DEFAULT();
|
|
|
|
// Set family VFD with 1MB member size
|
|
long memberSize = 1024 * 1024; // 1MB per family member
|
|
int result = hdf5_h.H5Pset_fapl_family(fapl, memberSize, memberFapl);
|
|
assertTrue("H5Pset_fapl_family failed", isSuccess(result));
|
|
|
|
// Get family VFD settings
|
|
MemorySegment membSizeSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
MemorySegment membFaplSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
result = hdf5_h.H5Pget_fapl_family(fapl, membSizeSeg, membFaplSeg);
|
|
assertTrue("H5Pget_fapl_family failed", isSuccess(result));
|
|
|
|
long retMembSize = membSizeSeg.get(ValueLayout.JAVA_LONG, 0);
|
|
assertEquals("Member size should match", memberSize, retMembSize);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_driver()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Get default driver (should be sec2)
|
|
long driverId = hdf5_h.H5Pget_driver(fapl);
|
|
assertTrue("Default driver ID should be valid", isValidId(driverId));
|
|
|
|
// Set core VFD
|
|
int result = hdf5_h.H5Pset_fapl_core(fapl, 1024, false);
|
|
assertTrue("H5Pset_fapl_core failed", isSuccess(result));
|
|
|
|
// Get driver again (should be core)
|
|
long coreDriverId = hdf5_h.H5Pget_driver(fapl);
|
|
assertTrue("Core driver ID should be valid", isValidId(coreDriverId));
|
|
|
|
// Driver IDs should be different
|
|
assertNotEquals("Driver IDs should differ after changing VFD", driverId, coreDriverId);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
// =========================
|
|
// File Image + MDC Configuration Tests (Batch 2)
|
|
// =========================
|
|
|
|
@Test
|
|
public void testH5Pset_file_image()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Create a small file image buffer (simulating an in-memory HDF5 file)
|
|
long imageSize = 1024; // 1KB
|
|
MemorySegment imageBuffer = arena.allocate(imageSize);
|
|
|
|
// Initialize buffer with some data
|
|
for (long i = 0; i < imageSize; i++) {
|
|
imageBuffer.set(ValueLayout.JAVA_BYTE, i, (byte)(i % 256));
|
|
}
|
|
|
|
// Set file image
|
|
int result = hdf5_h.H5Pset_file_image(fapl, imageBuffer, imageSize);
|
|
assertTrue("H5Pset_file_image failed", isSuccess(result));
|
|
|
|
// Get file image back
|
|
MemorySegment outBufferPtr = allocateLongArray(arena, 1);
|
|
MemorySegment outSize = allocateLongArray(arena, 1);
|
|
result = hdf5_h.H5Pget_file_image(fapl, outBufferPtr, outSize);
|
|
assertTrue("H5Pget_file_image failed", isSuccess(result));
|
|
|
|
// Verify size matches
|
|
long retrievedSize = getLong(outSize);
|
|
assertEquals("File image size should match", imageSize, retrievedSize);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_mdc_log_options()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set MDC (metadata cache) log options
|
|
boolean isEnabled = true;
|
|
String location = "test_mdc.log";
|
|
boolean startOnAccess = true;
|
|
|
|
int result = hdf5_h.H5Pset_mdc_log_options(fapl, isEnabled, stringToSegment(arena, location),
|
|
startOnAccess);
|
|
assertTrue("H5Pset_mdc_log_options failed", isSuccess(result));
|
|
|
|
// Get MDC log options back
|
|
MemorySegment outIsEnabled = allocateIntArray(arena, 1);
|
|
MemorySegment outLocation = arena.allocate(256);
|
|
MemorySegment outLocationSize = allocateLongArray(arena, 1);
|
|
MemorySegment outStartOnAccess = allocateIntArray(arena, 1);
|
|
|
|
result = hdf5_h.H5Pget_mdc_log_options(fapl, outIsEnabled, outLocation, outLocationSize,
|
|
outStartOnAccess);
|
|
assertTrue("H5Pget_mdc_log_options failed", isSuccess(result));
|
|
|
|
// Verify settings
|
|
boolean retrievedEnabled = getInt(outIsEnabled) != 0;
|
|
boolean retrievedStartOnAccess = getInt(outStartOnAccess) != 0;
|
|
assertEquals("MDC logging should be enabled", isEnabled, retrievedEnabled);
|
|
assertEquals("Start on access should match", startOnAccess, retrievedStartOnAccess);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
|
|
// Clean up log file if created
|
|
_deleteFile(location);
|
|
}
|
|
}
|
|
|
|
// =========================
|
|
// DXPL Enhancement Tests (Batch 3)
|
|
// =========================
|
|
|
|
@Test
|
|
public void testH5Pset_edc_check_disable()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dxpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_XFER_ID_g());
|
|
assertTrue("H5Pcreate dxpl failed", isValidId(dxpl));
|
|
|
|
// Disable error detection (EDC)
|
|
int result = hdf5_h.H5Pset_edc_check(dxpl, hdf5_h.H5Z_DISABLE_EDC());
|
|
assertTrue("H5Pset_edc_check failed", isSuccess(result));
|
|
|
|
// Get EDC check setting back
|
|
int edcCheck = hdf5_h.H5Pget_edc_check(dxpl);
|
|
assertEquals("EDC should be disabled", hdf5_h.H5Z_DISABLE_EDC(), edcCheck);
|
|
|
|
hdf5_h.H5Pclose(dxpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_edc_check_enable()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dxpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_XFER_ID_g());
|
|
assertTrue("H5Pcreate dxpl failed", isValidId(dxpl));
|
|
|
|
// Enable error detection (EDC)
|
|
int result = hdf5_h.H5Pset_edc_check(dxpl, hdf5_h.H5Z_ENABLE_EDC());
|
|
assertTrue("H5Pset_edc_check failed", isSuccess(result));
|
|
|
|
// Get EDC check setting back
|
|
int edcCheck = hdf5_h.H5Pget_edc_check(dxpl);
|
|
assertEquals("EDC should be enabled", hdf5_h.H5Z_ENABLE_EDC(), edcCheck);
|
|
|
|
hdf5_h.H5Pclose(dxpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_selection_io()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dxpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_XFER_ID_g());
|
|
assertTrue("H5Pcreate dxpl failed", isValidId(dxpl));
|
|
|
|
// Enable selection I/O
|
|
int result = hdf5_h.H5Pset_selection_io(dxpl, hdf5_h.H5D_SELECTION_IO_MODE_ON());
|
|
assertTrue("H5Pset_selection_io failed", isSuccess(result));
|
|
|
|
// Get selection I/O mode back
|
|
MemorySegment outMode = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_selection_io(dxpl, outMode);
|
|
assertTrue("H5Pget_selection_io failed", isSuccess(result));
|
|
|
|
int mode = getInt(outMode);
|
|
assertEquals("Selection I/O should be enabled", hdf5_h.H5D_SELECTION_IO_MODE_ON(), mode);
|
|
|
|
hdf5_h.H5Pclose(dxpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_selection_io_off()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dxpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_XFER_ID_g());
|
|
assertTrue("H5Pcreate dxpl failed", isValidId(dxpl));
|
|
|
|
// Disable selection I/O
|
|
int result = hdf5_h.H5Pset_selection_io(dxpl, hdf5_h.H5D_SELECTION_IO_MODE_OFF());
|
|
assertTrue("H5Pset_selection_io failed", isSuccess(result));
|
|
|
|
// Get selection I/O mode back
|
|
MemorySegment outMode = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_selection_io(dxpl, outMode);
|
|
assertTrue("H5Pget_selection_io failed", isSuccess(result));
|
|
|
|
int mode = getInt(outMode);
|
|
assertEquals("Selection I/O should be disabled", hdf5_h.H5D_SELECTION_IO_MODE_OFF(), mode);
|
|
|
|
hdf5_h.H5Pclose(dxpl);
|
|
}
|
|
}
|
|
|
|
// =========================
|
|
// Virtual Dataset Property Tests
|
|
// =========================
|
|
|
|
@Test
|
|
public void testH5Pset_virtual_basic()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create dataset creation property list
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Create virtual dataspace (10x20)
|
|
long[] vdimsArray = {10, 20};
|
|
MemorySegment vdims = allocateLongArray(arena, 2);
|
|
copyToSegment(vdims, vdimsArray);
|
|
long vspace = hdf5_h.H5Screate_simple(2, vdims, MemorySegment.NULL);
|
|
assertTrue("H5Screate_simple vspace failed", isValidId(vspace));
|
|
|
|
// Create source dataspace (10x20)
|
|
long[] sdimsArray = {10, 20};
|
|
MemorySegment sdims = allocateLongArray(arena, 2);
|
|
copyToSegment(sdims, sdimsArray);
|
|
long srcspace = hdf5_h.H5Screate_simple(2, sdims, MemorySegment.NULL);
|
|
assertTrue("H5Screate_simple srcspace failed", isValidId(srcspace));
|
|
|
|
// Set virtual mapping
|
|
MemorySegment srcFile = stringToSegment(arena, "source.h5");
|
|
MemorySegment srcDset = stringToSegment(arena, "/source_dataset");
|
|
int result = hdf5_h.H5Pset_virtual(dcpl, vspace, srcFile, srcDset, srcspace);
|
|
assertTrue("H5Pset_virtual failed", isSuccess(result));
|
|
|
|
// Get virtual count
|
|
MemorySegment count = allocateLongArray(arena, 1);
|
|
result = hdf5_h.H5Pget_virtual_count(dcpl, count);
|
|
assertTrue("H5Pget_virtual_count failed", isSuccess(result));
|
|
assertEquals("Should have 1 virtual mapping", 1L, getLong(count));
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Sclose(srcspace);
|
|
hdf5_h.H5Sclose(vspace);
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_virtual_filename()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Create dataspaces
|
|
long[] dimsArray = {100};
|
|
MemorySegment dims = allocateLongArray(arena, 1);
|
|
copyToSegment(dims, dimsArray);
|
|
long vspace = hdf5_h.H5Screate_simple(1, dims, MemorySegment.NULL);
|
|
long srcspace = hdf5_h.H5Screate_simple(1, dims, MemorySegment.NULL);
|
|
|
|
// Set virtual mapping with specific filename
|
|
String expectedFilename = "virtual_source_file.h5";
|
|
MemorySegment srcFile = stringToSegment(arena, expectedFilename);
|
|
MemorySegment srcDset = stringToSegment(arena, "/data");
|
|
hdf5_h.H5Pset_virtual(dcpl, vspace, srcFile, srcDset, srcspace);
|
|
|
|
// Query filename length
|
|
long nameLen = hdf5_h.H5Pget_virtual_filename(dcpl, 0, MemorySegment.NULL, 0);
|
|
assertTrue("H5Pget_virtual_filename length query failed", nameLen > 0);
|
|
|
|
// Get filename
|
|
MemorySegment nameBuf = arena.allocate(nameLen + 1);
|
|
long actualLen = hdf5_h.H5Pget_virtual_filename(dcpl, 0, nameBuf, nameLen + 1);
|
|
assertEquals("Filename length should match", nameLen, actualLen);
|
|
|
|
String actualFilename = segmentToString(nameBuf);
|
|
assertEquals("Filename should match", expectedFilename, actualFilename);
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Sclose(srcspace);
|
|
hdf5_h.H5Sclose(vspace);
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_virtual_dsetname()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Create dataspaces
|
|
long[] dimsArray = {50, 100};
|
|
MemorySegment dims = allocateLongArray(arena, 2);
|
|
copyToSegment(dims, dimsArray);
|
|
long vspace = hdf5_h.H5Screate_simple(2, dims, MemorySegment.NULL);
|
|
long srcspace = hdf5_h.H5Screate_simple(2, dims, MemorySegment.NULL);
|
|
|
|
// Set virtual mapping with specific dataset name
|
|
String expectedDsetName = "/group/virtual_dataset";
|
|
MemorySegment srcFile = stringToSegment(arena, "source.h5");
|
|
MemorySegment srcDset = stringToSegment(arena, expectedDsetName);
|
|
hdf5_h.H5Pset_virtual(dcpl, vspace, srcFile, srcDset, srcspace);
|
|
|
|
// Query dataset name length
|
|
long nameLen = hdf5_h.H5Pget_virtual_dsetname(dcpl, 0, MemorySegment.NULL, 0);
|
|
assertTrue("H5Pget_virtual_dsetname length query failed", nameLen > 0);
|
|
|
|
// Get dataset name
|
|
MemorySegment nameBuf = arena.allocate(nameLen + 1);
|
|
long actualLen = hdf5_h.H5Pget_virtual_dsetname(dcpl, 0, nameBuf, nameLen + 1);
|
|
assertEquals("Dataset name length should match", nameLen, actualLen);
|
|
|
|
String actualDsetName = segmentToString(nameBuf);
|
|
assertEquals("Dataset name should match", expectedDsetName, actualDsetName);
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Sclose(srcspace);
|
|
hdf5_h.H5Sclose(vspace);
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_virtual_vspace_and_srcspace()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Create virtual dataspace with specific dimensions
|
|
long[] vdimsArray = {30, 40};
|
|
MemorySegment vdims = allocateLongArray(arena, 2);
|
|
copyToSegment(vdims, vdimsArray);
|
|
long vspace = hdf5_h.H5Screate_simple(2, vdims, MemorySegment.NULL);
|
|
|
|
// Create source dataspace with different dimensions
|
|
long[] sdimsArray = {30, 40};
|
|
MemorySegment sdims = allocateLongArray(arena, 2);
|
|
copyToSegment(sdims, sdimsArray);
|
|
long srcspace = hdf5_h.H5Screate_simple(2, sdims, MemorySegment.NULL);
|
|
|
|
// Set virtual mapping
|
|
hdf5_h.H5Pset_virtual(dcpl, vspace, stringToSegment(arena, "src.h5"),
|
|
stringToSegment(arena, "/dset"), srcspace);
|
|
|
|
// Get virtual dataspace back
|
|
long retrieved_vspace = hdf5_h.H5Pget_virtual_vspace(dcpl, 0);
|
|
assertTrue("H5Pget_virtual_vspace failed", isValidId(retrieved_vspace));
|
|
|
|
// Verify virtual dataspace dimensions
|
|
MemorySegment retrieved_vdims = allocateLongArray(arena, 2);
|
|
hdf5_h.H5Sget_simple_extent_dims(retrieved_vspace, retrieved_vdims, MemorySegment.NULL);
|
|
assertEquals("Virtual dim 0 should match", 30L, retrieved_vdims.get(ValueLayout.JAVA_LONG, 0));
|
|
assertEquals("Virtual dim 1 should match", 40L, retrieved_vdims.get(ValueLayout.JAVA_LONG, 8));
|
|
|
|
// Get source dataspace back
|
|
long retrieved_srcspace = hdf5_h.H5Pget_virtual_srcspace(dcpl, 0);
|
|
assertTrue("H5Pget_virtual_srcspace failed", isValidId(retrieved_srcspace));
|
|
|
|
// Verify source dataspace dimensions
|
|
MemorySegment retrieved_sdims = allocateLongArray(arena, 2);
|
|
hdf5_h.H5Sget_simple_extent_dims(retrieved_srcspace, retrieved_sdims, MemorySegment.NULL);
|
|
assertEquals("Source dim 0 should match", 30L, retrieved_sdims.get(ValueLayout.JAVA_LONG, 0));
|
|
assertEquals("Source dim 1 should match", 40L, retrieved_sdims.get(ValueLayout.JAVA_LONG, 8));
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Sclose(retrieved_srcspace);
|
|
hdf5_h.H5Sclose(retrieved_vspace);
|
|
hdf5_h.H5Sclose(srcspace);
|
|
hdf5_h.H5Sclose(vspace);
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_virtual_view()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create dataset access property list
|
|
long dapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate dapl failed", isValidId(dapl));
|
|
|
|
// Set virtual view to FIRST_MISSING
|
|
int result = hdf5_h.H5Pset_virtual_view(dapl, hdf5_h.H5D_VDS_FIRST_MISSING());
|
|
assertTrue("H5Pset_virtual_view failed", isSuccess(result));
|
|
|
|
// Get virtual view back
|
|
MemorySegment view = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_virtual_view(dapl, view);
|
|
assertTrue("H5Pget_virtual_view failed", isSuccess(result));
|
|
assertEquals("View should be FIRST_MISSING", hdf5_h.H5D_VDS_FIRST_MISSING(), getInt(view));
|
|
|
|
// Change to LAST_AVAILABLE
|
|
result = hdf5_h.H5Pset_virtual_view(dapl, hdf5_h.H5D_VDS_LAST_AVAILABLE());
|
|
assertTrue("H5Pset_virtual_view (LAST_AVAILABLE) failed", isSuccess(result));
|
|
|
|
result = hdf5_h.H5Pget_virtual_view(dapl, view);
|
|
assertTrue("H5Pget_virtual_view (2nd call) failed", isSuccess(result));
|
|
assertEquals("View should be LAST_AVAILABLE", hdf5_h.H5D_VDS_LAST_AVAILABLE(), getInt(view));
|
|
|
|
hdf5_h.H5Pclose(dapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_copy_object_basic()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create object copy property list
|
|
long ocpypl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_OBJECT_COPY_ID_g());
|
|
assertTrue("H5Pcreate ocpypl failed", isValidId(ocpypl));
|
|
|
|
// Set copy options - shallow hierarchy
|
|
int copyOptions = hdf5_h.H5O_COPY_SHALLOW_HIERARCHY_FLAG();
|
|
int result = hdf5_h.H5Pset_copy_object(ocpypl, copyOptions);
|
|
assertTrue("H5Pset_copy_object failed", isSuccess(result));
|
|
|
|
// Get copy options back
|
|
MemorySegment options = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_copy_object(ocpypl, options);
|
|
assertTrue("H5Pget_copy_object failed", isSuccess(result));
|
|
|
|
int retrievedOptions = getInt(options);
|
|
assertEquals("Copy options should match", copyOptions, retrievedOptions);
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Pclose(ocpypl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_copy_object_multiple_flags()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long ocpypl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_OBJECT_COPY_ID_g());
|
|
assertTrue("H5Pcreate ocpypl failed", isValidId(ocpypl));
|
|
|
|
// Set multiple copy options with bitwise OR
|
|
int copyOptions = hdf5_h.H5O_COPY_SHALLOW_HIERARCHY_FLAG() | hdf5_h.H5O_COPY_WITHOUT_ATTR_FLAG();
|
|
int result = hdf5_h.H5Pset_copy_object(ocpypl, copyOptions);
|
|
assertTrue("H5Pset_copy_object failed", isSuccess(result));
|
|
|
|
// Verify
|
|
MemorySegment options = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_copy_object(ocpypl, options);
|
|
assertTrue("H5Pget_copy_object failed", isSuccess(result));
|
|
|
|
int retrievedOptions = getInt(options);
|
|
assertEquals("Copy options should match", copyOptions, retrievedOptions);
|
|
|
|
// Verify individual flags are set
|
|
assertTrue("Should have SHALLOW_HIERARCHY flag",
|
|
(retrievedOptions & hdf5_h.H5O_COPY_SHALLOW_HIERARCHY_FLAG()) != 0);
|
|
assertTrue("Should have WITHOUT_ATTR flag",
|
|
(retrievedOptions & hdf5_h.H5O_COPY_WITHOUT_ATTR_FLAG()) != 0);
|
|
|
|
hdf5_h.H5Pclose(ocpypl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_copy_object_expand_links()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long ocpypl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_OBJECT_COPY_ID_g());
|
|
assertTrue("H5Pcreate ocpypl failed", isValidId(ocpypl));
|
|
|
|
// Set options to expand soft and external links
|
|
int copyOptions =
|
|
hdf5_h.H5O_COPY_EXPAND_SOFT_LINK_FLAG() | hdf5_h.H5O_COPY_EXPAND_EXT_LINK_FLAG();
|
|
int result = hdf5_h.H5Pset_copy_object(ocpypl, copyOptions);
|
|
assertTrue("H5Pset_copy_object failed", isSuccess(result));
|
|
|
|
// Verify
|
|
MemorySegment options = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_copy_object(ocpypl, options);
|
|
assertTrue("H5Pget_copy_object failed", isSuccess(result));
|
|
|
|
int retrievedOptions = getInt(options);
|
|
assertTrue("Should have EXPAND_SOFT_LINK flag",
|
|
(retrievedOptions & hdf5_h.H5O_COPY_EXPAND_SOFT_LINK_FLAG()) != 0);
|
|
assertTrue("Should have EXPAND_EXT_LINK flag",
|
|
(retrievedOptions & hdf5_h.H5O_COPY_EXPAND_EXT_LINK_FLAG()) != 0);
|
|
|
|
hdf5_h.H5Pclose(ocpypl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_attr_phase_change()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create object creation property list
|
|
long ocpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_OBJECT_CREATE_ID_g());
|
|
assertTrue("H5Pcreate ocpl failed", isValidId(ocpl));
|
|
|
|
// Set attribute phase change thresholds
|
|
// max_compact: maximum number of attributes in compact storage
|
|
// min_dense: minimum number of attributes in dense storage
|
|
int maxCompact = 10;
|
|
int minDense = 8;
|
|
int result = hdf5_h.H5Pset_attr_phase_change(ocpl, maxCompact, minDense);
|
|
assertTrue("H5Pset_attr_phase_change failed", isSuccess(result));
|
|
|
|
// Get settings back
|
|
MemorySegment maxCompactOut = allocateIntArray(arena, 1);
|
|
MemorySegment minDenseOut = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_attr_phase_change(ocpl, maxCompactOut, minDenseOut);
|
|
assertTrue("H5Pget_attr_phase_change failed", isSuccess(result));
|
|
|
|
int retrievedMaxCompact = getInt(maxCompactOut);
|
|
int retrievedMinDense = getInt(minDenseOut);
|
|
assertEquals("Max compact should match", maxCompact, retrievedMaxCompact);
|
|
assertEquals("Min dense should match", minDense, retrievedMinDense);
|
|
|
|
hdf5_h.H5Pclose(ocpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_copy_object_preserve_null()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long ocpypl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_OBJECT_COPY_ID_g());
|
|
assertTrue("H5Pcreate ocpypl failed", isValidId(ocpypl));
|
|
|
|
// Test PRESERVE_NULL flag
|
|
int copyOptions = hdf5_h.H5O_COPY_PRESERVE_NULL_FLAG();
|
|
int result = hdf5_h.H5Pset_copy_object(ocpypl, copyOptions);
|
|
assertTrue("H5Pset_copy_object failed", isSuccess(result));
|
|
|
|
// Verify
|
|
MemorySegment options = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_copy_object(ocpypl, options);
|
|
assertTrue("H5Pget_copy_object failed", isSuccess(result));
|
|
|
|
int retrievedOptions = getInt(options);
|
|
assertEquals("Should have PRESERVE_NULL flag", copyOptions, retrievedOptions);
|
|
|
|
// Test with ALL flags
|
|
result = hdf5_h.H5Pset_copy_object(ocpypl, hdf5_h.H5O_COPY_ALL());
|
|
assertTrue("H5Pset_copy_object (ALL) failed", isSuccess(result));
|
|
|
|
result = hdf5_h.H5Pget_copy_object(ocpypl, options);
|
|
assertTrue("H5Pget_copy_object failed", isSuccess(result));
|
|
|
|
retrievedOptions = getInt(options);
|
|
assertEquals("Should have ALL flags", hdf5_h.H5O_COPY_ALL(), retrievedOptions);
|
|
|
|
hdf5_h.H5Pclose(ocpypl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_elink_prefix()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create link access property list
|
|
long lapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_LINK_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate lapl failed", isValidId(lapl));
|
|
|
|
// Set external link prefix
|
|
String prefix = "/path/to/external/files";
|
|
MemorySegment prefixSeg = stringToSegment(arena, prefix);
|
|
int result = hdf5_h.H5Pset_elink_prefix(lapl, prefixSeg);
|
|
assertTrue("H5Pset_elink_prefix failed", isSuccess(result));
|
|
|
|
// Query prefix length
|
|
long prefixLen = hdf5_h.H5Pget_elink_prefix(lapl, MemorySegment.NULL, 0);
|
|
assertTrue("Prefix length should be > 0", prefixLen > 0);
|
|
|
|
// Get prefix
|
|
MemorySegment prefixBuf = arena.allocate(prefixLen + 1);
|
|
long actualLen = hdf5_h.H5Pget_elink_prefix(lapl, prefixBuf, prefixLen + 1);
|
|
assertEquals("Prefix length should match", prefixLen, actualLen);
|
|
|
|
String retrievedPrefix = segmentToString(prefixBuf);
|
|
assertEquals("Prefix should match", prefix, retrievedPrefix);
|
|
|
|
hdf5_h.H5Pclose(lapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_elink_fapl()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create link access property list
|
|
long lapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_LINK_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate lapl failed", isValidId(lapl));
|
|
|
|
// Create file access property list to use for external links
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set external link file access property list
|
|
int result = hdf5_h.H5Pset_elink_fapl(lapl, fapl);
|
|
assertTrue("H5Pset_elink_fapl failed", isSuccess(result));
|
|
|
|
// Get external link fapl
|
|
long retrievedFapl = hdf5_h.H5Pget_elink_fapl(lapl);
|
|
assertTrue("Retrieved fapl should be valid", isValidId(retrievedFapl));
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Pclose(retrievedFapl);
|
|
hdf5_h.H5Pclose(fapl);
|
|
hdf5_h.H5Pclose(lapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_link_creation_order()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create group creation property list
|
|
long gcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_GROUP_CREATE_ID_g());
|
|
assertTrue("H5Pcreate gcpl failed", isValidId(gcpl));
|
|
|
|
// Set link creation order tracking and indexing
|
|
int crtOrderFlags = hdf5_h.H5P_CRT_ORDER_TRACKED() | hdf5_h.H5P_CRT_ORDER_INDEXED();
|
|
int result = hdf5_h.H5Pset_link_creation_order(gcpl, crtOrderFlags);
|
|
assertTrue("H5Pset_link_creation_order failed", isSuccess(result));
|
|
|
|
// Get link creation order flags
|
|
MemorySegment flags = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_link_creation_order(gcpl, flags);
|
|
assertTrue("H5Pget_link_creation_order failed", isSuccess(result));
|
|
|
|
int retrievedFlags = getInt(flags);
|
|
assertEquals("Flags should match", crtOrderFlags, retrievedFlags);
|
|
|
|
// Verify individual flags
|
|
assertTrue("Should have TRACKED flag", (retrievedFlags & hdf5_h.H5P_CRT_ORDER_TRACKED()) != 0);
|
|
assertTrue("Should have INDEXED flag", (retrievedFlags & hdf5_h.H5P_CRT_ORDER_INDEXED()) != 0);
|
|
|
|
hdf5_h.H5Pclose(gcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_est_link_info()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create group creation property list
|
|
long gcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_GROUP_CREATE_ID_g());
|
|
assertTrue("H5Pcreate gcpl failed", isValidId(gcpl));
|
|
|
|
// Set estimated link info (number of links, length of link names)
|
|
int estNumEntries = 50;
|
|
int estNameLen = 20;
|
|
int result = hdf5_h.H5Pset_est_link_info(gcpl, estNumEntries, estNameLen);
|
|
assertTrue("H5Pset_est_link_info failed", isSuccess(result));
|
|
|
|
// Get estimated link info
|
|
MemorySegment numEntries = allocateIntArray(arena, 1);
|
|
MemorySegment nameLen = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_est_link_info(gcpl, numEntries, nameLen);
|
|
assertTrue("H5Pget_est_link_info failed", isSuccess(result));
|
|
|
|
assertEquals("Number of entries should match", estNumEntries, getInt(numEntries));
|
|
assertEquals("Name length should match", estNameLen, getInt(nameLen));
|
|
|
|
hdf5_h.H5Pclose(gcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_link_phase_change()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create group creation property list
|
|
long gcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_GROUP_CREATE_ID_g());
|
|
assertTrue("H5Pcreate gcpl failed", isValidId(gcpl));
|
|
|
|
// Set link phase change thresholds
|
|
// max_compact: maximum number of links in compact storage
|
|
// min_dense: minimum number of links in dense storage
|
|
int maxCompact = 12;
|
|
int minDense = 10;
|
|
int result = hdf5_h.H5Pset_link_phase_change(gcpl, maxCompact, minDense);
|
|
assertTrue("H5Pset_link_phase_change failed", isSuccess(result));
|
|
|
|
// Get link phase change thresholds
|
|
MemorySegment maxCompactOut = allocateIntArray(arena, 1);
|
|
MemorySegment minDenseOut = allocateIntArray(arena, 1);
|
|
result = hdf5_h.H5Pget_link_phase_change(gcpl, maxCompactOut, minDenseOut);
|
|
assertTrue("H5Pget_link_phase_change failed", isSuccess(result));
|
|
|
|
assertEquals("Max compact should match", maxCompact, getInt(maxCompactOut));
|
|
assertEquals("Min dense should match", minDense, getInt(minDenseOut));
|
|
|
|
hdf5_h.H5Pclose(gcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_evict_on_close()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set evict on close to true
|
|
int result = hdf5_h.H5Pset_evict_on_close(fapl, true);
|
|
assertTrue("H5Pset_evict_on_close failed", isSuccess(result));
|
|
|
|
// Get evict on close setting
|
|
MemorySegment evictSeg = arena.allocate(ValueLayout.JAVA_BOOLEAN);
|
|
result = hdf5_h.H5Pget_evict_on_close(fapl, evictSeg);
|
|
assertTrue("H5Pget_evict_on_close failed", isSuccess(result));
|
|
|
|
boolean evict = evictSeg.get(ValueLayout.JAVA_BOOLEAN, 0);
|
|
assertTrue("Evict on close should be true", evict);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_file_locking()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set file locking (use_file_locking=true, ignore_when_disabled=false)
|
|
int result = hdf5_h.H5Pset_file_locking(fapl, true, false);
|
|
assertTrue("H5Pset_file_locking failed", isSuccess(result));
|
|
|
|
// Get file locking settings
|
|
MemorySegment useLockingSeg = arena.allocate(ValueLayout.JAVA_BOOLEAN);
|
|
MemorySegment ignoreFailSeg = arena.allocate(ValueLayout.JAVA_BOOLEAN);
|
|
result = hdf5_h.H5Pget_file_locking(fapl, useLockingSeg, ignoreFailSeg);
|
|
assertTrue("H5Pget_file_locking failed", isSuccess(result));
|
|
|
|
boolean useLocking = useLockingSeg.get(ValueLayout.JAVA_BOOLEAN, 0);
|
|
boolean ignoreFail = ignoreFailSeg.get(ValueLayout.JAVA_BOOLEAN, 0);
|
|
assertTrue("Use locking should be true", useLocking);
|
|
assertFalse("Ignore fail should be false", ignoreFail);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_page_buffer_size()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set page buffer size (4MB buffer, 50% metadata, 25% raw data)
|
|
long bufSize = 4 * 1024 * 1024; // 4MB
|
|
int minMetaPct = 50;
|
|
int minRawPct = 25;
|
|
int result = hdf5_h.H5Pset_page_buffer_size(fapl, bufSize, minMetaPct, minRawPct);
|
|
assertTrue("H5Pset_page_buffer_size failed", isSuccess(result));
|
|
|
|
// Get page buffer size
|
|
MemorySegment bufSizeSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
MemorySegment minMetaPctSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
MemorySegment minRawPctSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
result = hdf5_h.H5Pget_page_buffer_size(fapl, bufSizeSeg, minMetaPctSeg, minRawPctSeg);
|
|
assertTrue("H5Pget_page_buffer_size failed", isSuccess(result));
|
|
|
|
long retBufSize = bufSizeSeg.get(ValueLayout.JAVA_LONG, 0);
|
|
int retMetaPct = minMetaPctSeg.get(ValueLayout.JAVA_INT, 0);
|
|
int retRawPct = minRawPctSeg.get(ValueLayout.JAVA_INT, 0);
|
|
|
|
assertEquals("Buffer size should match", bufSize, retBufSize);
|
|
assertEquals("Metadata percent should match", minMetaPct, retMetaPct);
|
|
assertEquals("Raw data percent should match", minRawPct, retRawPct);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_metadata_read_attempts()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long fapl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_FILE_ACCESS_ID_g());
|
|
assertTrue("H5Pcreate fapl failed", isValidId(fapl));
|
|
|
|
// Set metadata read attempts to 5
|
|
int attempts = 5;
|
|
int result = hdf5_h.H5Pset_metadata_read_attempts(fapl, attempts);
|
|
assertTrue("H5Pset_metadata_read_attempts failed", isSuccess(result));
|
|
|
|
// Get metadata read attempts
|
|
MemorySegment attemptsSeg = arena.allocate(ValueLayout.JAVA_INT);
|
|
result = hdf5_h.H5Pget_metadata_read_attempts(fapl, attemptsSeg);
|
|
assertTrue("H5Pget_metadata_read_attempts failed", isSuccess(result));
|
|
|
|
int retAttempts = attemptsSeg.get(ValueLayout.JAVA_INT, 0);
|
|
assertEquals("Attempts should match", attempts, retAttempts);
|
|
|
|
hdf5_h.H5Pclose(fapl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_obj_track_times()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
long ocpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_OBJECT_CREATE_ID_g());
|
|
assertTrue("H5Pcreate ocpl failed", isValidId(ocpl));
|
|
|
|
// Set object time tracking to false
|
|
int result = hdf5_h.H5Pset_obj_track_times(ocpl, false);
|
|
assertTrue("H5Pset_obj_track_times failed", isSuccess(result));
|
|
|
|
// Get object time tracking setting
|
|
MemorySegment trackSeg = arena.allocate(ValueLayout.JAVA_BOOLEAN);
|
|
result = hdf5_h.H5Pget_obj_track_times(ocpl, trackSeg);
|
|
assertTrue("H5Pget_obj_track_times failed", isSuccess(result));
|
|
|
|
boolean track = trackSeg.get(ValueLayout.JAVA_BOOLEAN, 0);
|
|
assertFalse("Track times should be false", track);
|
|
|
|
hdf5_h.H5Pclose(ocpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_virtual_info()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create DCPL with virtual dataset mapping
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
long[] dims = {5, 10};
|
|
MemorySegment dimsSeg = arena.allocateFrom(ValueLayout.JAVA_LONG, dims);
|
|
long vspace = hdf5_h.H5Screate_simple(2, dimsSeg, MemorySegment.NULL);
|
|
long srcspace = hdf5_h.H5Screate_simple(2, dimsSeg, MemorySegment.NULL);
|
|
|
|
MemorySegment srcFileName = stringToSegment(arena, "test_source.h5");
|
|
MemorySegment srcDsetName = stringToSegment(arena, "/data");
|
|
hdf5_h.H5Pset_virtual(dcpl, vspace, srcFileName, srcDsetName, srcspace);
|
|
|
|
// Get virtual dataset info
|
|
MemorySegment count = allocateLongArray(arena, 1);
|
|
int result = hdf5_h.H5Pget_virtual_count(dcpl, count);
|
|
assertTrue("H5Pget_virtual_count failed", isSuccess(result));
|
|
long vcount = count.get(ValueLayout.JAVA_LONG, 0);
|
|
assertEquals("Should have 1 virtual mapping", 1, vcount);
|
|
|
|
// Get virtual vspace for index 0
|
|
long retrieved_vspace = hdf5_h.H5Pget_virtual_vspace(dcpl, 0);
|
|
assertTrue("H5Pget_virtual_vspace should succeed", isValidId(retrieved_vspace));
|
|
|
|
// Get virtual source space for index 0
|
|
long retrieved_srcspace = hdf5_h.H5Pget_virtual_srcspace(dcpl, 0);
|
|
assertTrue("H5Pget_virtual_srcspace should succeed", isValidId(retrieved_srcspace));
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Sclose(retrieved_vspace);
|
|
hdf5_h.H5Sclose(retrieved_srcspace);
|
|
hdf5_h.H5Sclose(vspace);
|
|
hdf5_h.H5Sclose(srcspace);
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_external()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create DCPL for external storage
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Add external file
|
|
MemorySegment extFile = stringToSegment(arena, "external_data.bin");
|
|
long offset = 0;
|
|
long size = 1024; // 1KB
|
|
int result = hdf5_h.H5Pset_external(dcpl, extFile, offset, size);
|
|
assertTrue("H5Pset_external failed", isSuccess(result));
|
|
|
|
// Get external file count
|
|
int extCount = hdf5_h.H5Pget_external_count(dcpl);
|
|
assertEquals("Should have 1 external file", 1, extCount);
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pget_external()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create DCPL and add external file
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
String extFileName = "my_external.bin";
|
|
MemorySegment extFile = stringToSegment(arena, extFileName);
|
|
long offset = 1024;
|
|
long size = 4096;
|
|
hdf5_h.H5Pset_external(dcpl, extFile, offset, size);
|
|
|
|
// Get external file info
|
|
int nameSize = 256;
|
|
MemorySegment nameBuf = arena.allocate(nameSize);
|
|
MemorySegment offsetSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
MemorySegment sizeSeg = arena.allocate(ValueLayout.JAVA_LONG);
|
|
|
|
long retval = hdf5_h.H5Pget_external(dcpl, 0, nameSize, nameBuf, offsetSeg, sizeSeg);
|
|
assertTrue("H5Pget_external should succeed", retval >= 0);
|
|
|
|
// Verify retrieved values
|
|
String retrievedName = segmentToString(nameBuf);
|
|
assertEquals("File name should match", extFileName, retrievedName);
|
|
|
|
long retrievedOffset = offsetSeg.get(ValueLayout.JAVA_LONG, 0);
|
|
assertEquals("Offset should match", offset, retrievedOffset);
|
|
|
|
long retrievedSize = sizeSeg.get(ValueLayout.JAVA_LONG, 0);
|
|
assertEquals("Size should match", size, retrievedSize);
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testH5Pset_external_multiple()
|
|
{
|
|
System.out.print(testname.getMethodName());
|
|
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
// Create DCPL
|
|
long dcpl = hdf5_h.H5Pcreate(hdf5_h.H5P_CLS_DATASET_CREATE_ID_g());
|
|
assertTrue("H5Pcreate dcpl failed", isValidId(dcpl));
|
|
|
|
// Add multiple external files
|
|
hdf5_h.H5Pset_external(dcpl, stringToSegment(arena, "ext1.bin"), 0, 1024);
|
|
hdf5_h.H5Pset_external(dcpl, stringToSegment(arena, "ext2.bin"), 0, 2048);
|
|
hdf5_h.H5Pset_external(dcpl, stringToSegment(arena, "ext3.bin"), 0, 4096);
|
|
|
|
// Verify count
|
|
int extCount = hdf5_h.H5Pget_external_count(dcpl);
|
|
assertEquals("Should have 3 external files", 3, extCount);
|
|
|
|
// Cleanup
|
|
hdf5_h.H5Pclose(dcpl);
|
|
}
|
|
}
|
|
}
|