mirror of
https://github.com/HDFGroup/hdf5.git
synced 2025-01-06 14:56:51 +08:00
a1708eb023
New feature Description: Check in baseline for compact group revisions, which radically revises the source code for managing groups and object headers. WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! This initiates the "unstable" phase of the 1.7.x branch, leading up to the 1.8.0 release. Please test this code, but do _NOT_ keep files created with it - the format will change again before the release and you will not be able to read your old files!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! WARNING!!!! Solution: There's too many changes to really describe them all, but some of them include: - Stop abusing the H5G_entry_t structure and split it into two separate structures for non-symbol table node use within the library: H5O_loc_t for object locations in a file and H5G_name_t to store the path to an opened object. H5G_entry_t is now only used for storing symbol table entries on disk. - Retire H5G_namei() in favor of a more general mechanism for traversing group paths and issuing callbacks on objects located. This gets us out of the business of hacking H5G_namei() for new features, generally. - Revised H5O* routines to take a H5O_loc_t instead of H5G_entry_t - Lots more... Platforms tested: h5committested and maybe another dozen configurations.... :-)
860 lines
27 KiB
C
860 lines
27 KiB
C
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* Copyright by the Board of Trustees of the University of Illinois. *
|
|
* All rights reserved. *
|
|
* *
|
|
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
|
* terms governing use, modification, and redistribution, is contained in *
|
|
* the files COPYING and Copyright.html. COPYING can be found at the root *
|
|
* of the source code distribution tree; Copyright.html can be found at the *
|
|
* root level of an installed copy of the electronic HDF5 document set and *
|
|
* is linked from the top-level documents page. It can also be found at *
|
|
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
|
|
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
/* Unicode test */
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include "testhdf5.h"
|
|
|
|
#define NUM_CHARS 16
|
|
#define MAX_STRING_LENGTH ((NUM_CHARS * 4) + 1) /* Max length in bytes */
|
|
#define MAX_PATH_LENGTH (MAX_STRING_LENGTH + 20) /* Max length in bytes */
|
|
#define MAX_CODE_POINT 0x200000
|
|
#define FILENAME "unicode.h5"
|
|
/* A buffer to hold two copies of the UTF-8 string */
|
|
#define LONG_BUF_SIZE (2 * MAX_STRING_LENGTH + 4)
|
|
|
|
#define DSET1_NAME "fl_string_dataset"
|
|
#define DSET2_NAME "dataset2"
|
|
#define DSET3_NAME "dataset3"
|
|
#define DSET4_NAME "dataset4"
|
|
#define VL_DSET1_NAME "vl_dset_1"
|
|
#define VL_DSET2_NAME "vl_dset_2"
|
|
#define GROUP1_NAME "group1"
|
|
#define GROUP2_NAME "group2"
|
|
#define GROUP3_NAME "group3"
|
|
#define GROUP4_NAME "group4"
|
|
#define SLINK_NAME "soft_link"
|
|
|
|
#define RANK 1
|
|
#define COMP_INT_VAL 7
|
|
#define COMP_FLOAT_VAL -42.0
|
|
#define COMP_DOUBLE_VAL 42.0
|
|
|
|
/* Test function prototypes */
|
|
void test_fl_string(hid_t fid, const char *string);
|
|
void test_strpad(hid_t fid, const char *string);
|
|
void test_vl_string(hid_t fid, const char *string);
|
|
void test_objnames(hid_t fid, const char *string);
|
|
void test_attrname(hid_t fid, const char *string);
|
|
void test_compound(hid_t fid, const char *string);
|
|
void test_enum(hid_t fid, const char *string);
|
|
void test_opaque(hid_t fid, const char *string);
|
|
|
|
/* Utility function prototypes */
|
|
static hid_t mkstr(size_t len, H5T_str_t strpad);
|
|
unsigned int write_char(unsigned int c, char * test_string, unsigned int cur_pos);
|
|
void dump_string(const char * string);
|
|
|
|
/*
|
|
* test_fl_string
|
|
* Tests that UTF-8 can be used for fixed-length string data.
|
|
* Writes the string to a dataset and reads it back again.
|
|
*/
|
|
void test_fl_string(hid_t fid, const char *string)
|
|
{
|
|
hid_t dtype_id, space_id, dset_id;
|
|
hsize_t dims=1;
|
|
char read_buf[MAX_STRING_LENGTH];
|
|
H5T_cset_t cset;
|
|
herr_t ret;
|
|
|
|
/* Create the datatype, ensure that the character set behaves
|
|
* correctly (it should default to ASCII and can be set to UTF8)
|
|
*/
|
|
dtype_id = H5Tcopy(H5T_C_S1);
|
|
CHECK(dtype_id, FAIL, "H5Tcopy");
|
|
ret=H5Tset_size(dtype_id, MAX_STRING_LENGTH);
|
|
CHECK(ret, FAIL, "H5Tset_size");
|
|
cset=H5Tget_cset(dtype_id);
|
|
VERIFY(cset, H5T_CSET_ASCII, "H5Tget_cset");
|
|
ret=H5Tset_cset(dtype_id, H5T_CSET_UTF8);
|
|
CHECK(ret, FAIL, "H5Tset_cset");
|
|
cset=H5Tget_cset(dtype_id);
|
|
VERIFY(cset, H5T_CSET_UTF8, "H5Tget_cset");
|
|
|
|
/* Create dataspace for a dataset */
|
|
space_id = H5Screate_simple(RANK, &dims, NULL);
|
|
CHECK(space_id, FAIL, "H5Screate_simple");
|
|
/* Create a dataset */
|
|
dset_id=H5Dcreate(fid, DSET1_NAME, dtype_id, space_id, H5P_DEFAULT);
|
|
CHECK(dset_id, FAIL, "H5Dcreate");
|
|
|
|
/* Write UTF-8 string to dataset */
|
|
ret = H5Dwrite(dset_id, dtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, string);
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
/* Read string back and make sure it is unchanged */
|
|
ret = H5Dread(dset_id, dtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, read_buf);
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
VERIFY(strcmp(string, read_buf), 0, "strcmp");
|
|
|
|
/* Close all */
|
|
ret=H5Dclose(dset_id);
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
ret=H5Tclose(dtype_id);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
ret=H5Sclose(space_id);
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
}
|
|
|
|
/*
|
|
* test_strpad
|
|
* Tests string padding for a UTF-8 string.
|
|
* Converts strings to shorter and then longer strings.
|
|
* Borrows heavily from dtypes.c, but is more complicated because
|
|
* the string is randomly generated.
|
|
*/
|
|
void test_strpad(hid_t UNUSED fid, const char *string)
|
|
{
|
|
/* buf is used to hold the data that H5Tconvert operates on. */
|
|
char buf[LONG_BUF_SIZE];
|
|
|
|
/* cmpbuf holds the output that H5Tconvert should produce,
|
|
* to compare against the actual output. */
|
|
char cmpbuf[LONG_BUF_SIZE];
|
|
|
|
/* new_string is a slightly modified version of the UTF-8
|
|
* string to make the tests run more smoothly. */
|
|
char new_string[MAX_STRING_LENGTH + 2];
|
|
|
|
unsigned int length; /* Length of new_string in bytes */
|
|
unsigned int small_len; /* Size of the small datatype */
|
|
unsigned int big_len; /* Size of the larger datatype */
|
|
hid_t src_type, dst_type;
|
|
herr_t ret;
|
|
|
|
/* The following tests are simpler if the UTF-8 string contains
|
|
* the right number of bytes (even or odd, depending on the test).
|
|
* We create a 'new_string' whose length is convenient by prepending
|
|
* an 'x' to 'string' when necessary. */
|
|
length = strlen(string);
|
|
if(length % 2 != 1)
|
|
{
|
|
strcpy(new_string, "x");
|
|
strcat(new_string, string);
|
|
length++;
|
|
} else {
|
|
strcpy(new_string, string);
|
|
}
|
|
|
|
|
|
/* Convert a null-terminated string to a shorter and longer null
|
|
* terminated string. */
|
|
|
|
/* Create a src_type that holds the UTF-8 string and its final NULL */
|
|
big_len = length + 1; /* +1 byte for final NULL */
|
|
src_type = mkstr(big_len, H5T_STR_NULLTERM);
|
|
CHECK(src_type, FAIL, "mkstr");
|
|
/* Create a dst_type that holds half of the UTF-8 string and a final
|
|
* NULL */
|
|
small_len = (length +1) / 2;
|
|
dst_type = mkstr(small_len, H5T_STR_NULLTERM);
|
|
CHECK(dst_type, FAIL, "mkstr");
|
|
|
|
/* Fill the buffer with two copies of the UTF-8 string, each with a
|
|
* terminating NULL. It will look like "abcdefg\0abcdefg\0". */
|
|
strncpy(buf, new_string, big_len);
|
|
strncpy(&buf[big_len], new_string, big_len);
|
|
|
|
ret = H5Tconvert(src_type, dst_type, 2, buf, NULL, H5P_DEFAULT);
|
|
CHECK(ret, FAIL, "H5Tconvert");
|
|
|
|
/* After conversion, the buffer should look like
|
|
* "abc\0abc\0abcdefg\0". Note that this is just what the bytes look
|
|
* like; UTF-8 characters may well have been truncated.
|
|
* To check that the conversion worked properly, we'll build this
|
|
* string manually. */
|
|
strncpy(cmpbuf, new_string, small_len -1);
|
|
cmpbuf[small_len - 1] = '\0';
|
|
strncpy(&cmpbuf[small_len], new_string, small_len -1);
|
|
cmpbuf[2 * small_len - 1] = '\0';
|
|
strcpy(&cmpbuf[2 * small_len], new_string);
|
|
|
|
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
|
|
|
|
/* Now convert from smaller datatype to bigger datatype. This should
|
|
* leave our buffer looking like: "abc\0\0\0\0\0abc\0\0\0\0\0" */
|
|
ret = H5Tconvert(dst_type, src_type, 2, buf, NULL, H5P_DEFAULT);
|
|
CHECK(ret, FAIL, "H5Tconvert");
|
|
|
|
/* First fill the buffer with NULLs */
|
|
HDmemset(cmpbuf, '\0', LONG_BUF_SIZE);
|
|
/* Copy in the characters */
|
|
strncpy(cmpbuf, new_string, small_len -1);
|
|
strncpy(&cmpbuf[big_len], new_string, small_len -1);
|
|
|
|
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
|
|
|
|
ret = H5Tclose(src_type);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
ret = H5Tclose(dst_type);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
|
|
|
|
/* Now test null padding. Null-padded strings do *not* need
|
|
* terminating NULLs, so the sizes of the datatypes are slightly
|
|
* different and we want a string with an even number of characters. */
|
|
length = strlen(string);
|
|
if(length % 2 != 0)
|
|
{
|
|
strcpy(new_string, "x");
|
|
strcat(new_string, string);
|
|
length++;
|
|
} else {
|
|
strcpy(new_string, string);
|
|
}
|
|
|
|
/* Create a src_type that holds the UTF-8 string */
|
|
big_len = length;
|
|
src_type = mkstr(big_len, H5T_STR_NULLPAD);
|
|
CHECK(src_type, FAIL, "mkstr");
|
|
/* Create a dst_type that holds half of the UTF-8 string */
|
|
small_len = length / 2;
|
|
dst_type = mkstr(small_len, H5T_STR_NULLPAD);
|
|
CHECK(dst_type, FAIL, "mkstr");
|
|
|
|
/* Fill the buffer with two copies of the UTF-8 string.
|
|
* It will look like "abcdefghabcdefgh". */
|
|
strncpy(buf, new_string, big_len);
|
|
strncpy(&buf[big_len], new_string, big_len);
|
|
|
|
ret = H5Tconvert(src_type, dst_type, 2, buf, NULL, H5P_DEFAULT);
|
|
CHECK(ret, FAIL, "H5Tconvert");
|
|
|
|
/* After conversion, the buffer should look like
|
|
* "abcdabcdabcdefgh". Note that this is just what the bytes look
|
|
* like; UTF-8 characters may well have been truncated.
|
|
* To check that the conversion worked properly, we'll build this
|
|
* string manually. */
|
|
strncpy(cmpbuf, new_string, small_len);
|
|
strncpy(&cmpbuf[small_len], new_string, small_len);
|
|
strncpy(&cmpbuf[2 * small_len], new_string, big_len);
|
|
|
|
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
|
|
|
|
/* Now convert from smaller datatype to bigger datatype. This should
|
|
* leave our buffer looking like: "abcd\0\0\0\0abcd\0\0\0\0" */
|
|
ret = H5Tconvert(dst_type, src_type, 2, buf, NULL, H5P_DEFAULT);
|
|
CHECK(ret, FAIL, "H5Tconvert");
|
|
|
|
/* First fill the buffer with NULLs */
|
|
HDmemset(cmpbuf, '\0', LONG_BUF_SIZE);
|
|
/* Copy in the characters */
|
|
strncpy(cmpbuf, new_string, small_len);
|
|
strncpy(&cmpbuf[big_len], new_string, small_len);
|
|
|
|
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
|
|
|
|
ret = H5Tclose(src_type);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
ret = H5Tclose(dst_type);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
|
|
|
|
/* Test space padding. This is very similar to null-padding; we can
|
|
use the same values of length, small_len, and big_len. */
|
|
|
|
src_type = mkstr(big_len, H5T_STR_SPACEPAD);
|
|
CHECK(src_type, FAIL, "mkstr");
|
|
dst_type = mkstr(small_len, H5T_STR_SPACEPAD);
|
|
CHECK(src_type, FAIL, "mkstr");
|
|
|
|
/* Fill the buffer with two copies of the UTF-8 string.
|
|
* It will look like "abcdefghabcdefgh". */
|
|
strcpy(buf, new_string);
|
|
strcpy(&buf[big_len], new_string);
|
|
|
|
ret = H5Tconvert(src_type, dst_type, 2, buf, NULL, H5P_DEFAULT);
|
|
CHECK(ret, FAIL, "H5Tconvert");
|
|
|
|
/* After conversion, the buffer should look like
|
|
* "abcdabcdabcdefgh". Note that this is just what the bytes look
|
|
* like; UTF-8 characters may have been truncated.
|
|
* To check that the conversion worked properly, we'll build this
|
|
* string manually. */
|
|
strncpy(cmpbuf, new_string, small_len);
|
|
strncpy(&cmpbuf[small_len], new_string, small_len);
|
|
strncpy(&cmpbuf[2 * small_len], new_string, big_len);
|
|
|
|
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
|
|
|
|
/* Now convert from smaller datatype to bigger datatype. This should
|
|
* leave our buffer looking like: "abcd abcd " */
|
|
ret = H5Tconvert(dst_type, src_type, 2, buf, NULL, H5P_DEFAULT);
|
|
CHECK(ret, FAIL, "H5Tconvert");
|
|
|
|
/* First fill the buffer with spaces */
|
|
HDmemset(cmpbuf, ' ', LONG_BUF_SIZE);
|
|
/* Copy in the characters */
|
|
strncpy(cmpbuf, new_string, small_len);
|
|
strncpy(&cmpbuf[big_len], new_string, small_len);
|
|
|
|
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
|
|
|
|
ret = H5Tclose(src_type);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
ret = H5Tclose(dst_type);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
}
|
|
|
|
|
|
/*
|
|
* test_vl_string
|
|
* Tests variable-length string datatype with UTF-8 strings.
|
|
*/
|
|
void test_vl_string(hid_t fid, const char *string)
|
|
{
|
|
hid_t type_id, space_id, dset_id;
|
|
hsize_t dims=1;
|
|
hsize_t size; /* Number of bytes used */
|
|
char *read_buf[1];
|
|
herr_t ret;
|
|
|
|
/* Create dataspace for datasets */
|
|
space_id = H5Screate_simple(RANK, &dims, NULL);
|
|
CHECK(space_id, FAIL, "H5Screate_simple");
|
|
|
|
/* Create a datatype to refer to */
|
|
type_id = H5Tcopy(H5T_C_S1);
|
|
CHECK(type_id, FAIL, "H5Tcopy");
|
|
ret = H5Tset_size(type_id, H5T_VARIABLE);
|
|
CHECK(ret, FAIL, "H5Tset_size");
|
|
|
|
/* Create a dataset */
|
|
dset_id=H5Dcreate(fid, VL_DSET1_NAME, type_id, space_id, H5P_DEFAULT);
|
|
CHECK(dset_id, FAIL, "H5Dcreate");
|
|
|
|
/* Write dataset to disk */
|
|
ret=H5Dwrite(dset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, &string);
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
/* Make certain the correct amount of memory will be used */
|
|
ret=H5Dvlen_get_buf_size(dset_id, type_id, space_id, &size);
|
|
CHECK(ret, FAIL, "H5Dvlen_get_buf_size");
|
|
VERIFY(size, (hsize_t)strlen(string) + 1, "H5Dvlen_get_buf_size");
|
|
|
|
/* Read dataset from disk */
|
|
ret=H5Dread(dset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, read_buf);
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
/* Compare data read in */
|
|
VERIFY(strcmp(string, read_buf[0]), 0, "strcmp");
|
|
|
|
/* Reclaim the read VL data */
|
|
ret=H5Dvlen_reclaim(type_id, space_id, H5P_DEFAULT, read_buf);
|
|
CHECK(ret, FAIL, "H5Dvlen_reclaim");
|
|
|
|
/* Close all */
|
|
ret = H5Dclose(dset_id);
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
ret = H5Tclose(type_id);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
ret = H5Sclose(space_id);
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
}
|
|
|
|
/*
|
|
* test_objnames
|
|
* Tests that UTF-8 can be used for object names in the file.
|
|
* Tests groups, datasets, named datatypes, and soft links.
|
|
*/
|
|
void test_objnames(hid_t fid, const char* string)
|
|
{
|
|
hid_t grp_id, grp1_id, grp2_id, grp3_id;
|
|
hid_t type_id, dset_id, space_id;
|
|
char read_buf[MAX_STRING_LENGTH];
|
|
char path_buf[MAX_PATH_LENGTH];
|
|
hsize_t dims=1;
|
|
hobj_ref_t obj_ref;
|
|
herr_t ret;
|
|
|
|
/* Create a group with a UTF-8 name */
|
|
grp_id = H5Gcreate(fid, string, 0);
|
|
CHECK(grp_id, FAIL, "H5Gcreate");
|
|
|
|
/* Set a comment on the group to test that we can access the group
|
|
* Also test that UTF-8 comments can be read.
|
|
*/
|
|
ret = H5Gset_comment(fid, string, string);
|
|
CHECK(ret, FAIL, "H5Gset_comment");
|
|
ret = H5Gget_comment(fid, string, MAX_STRING_LENGTH, read_buf);
|
|
CHECK(ret, FAIL, "H5Gget_comment");
|
|
|
|
ret = H5Gclose(grp_id);
|
|
CHECK(ret, FAIL, "H5Gclose");
|
|
|
|
VERIFY(strcmp(string, read_buf), 0, "strcmp");
|
|
|
|
/* Create a new dataset with a UTF-8 name */
|
|
grp1_id = H5Gcreate(fid, GROUP1_NAME, 0);
|
|
CHECK(grp1_id, FAIL, "H5Gcreate");
|
|
|
|
space_id = H5Screate_simple(RANK, &dims, NULL);
|
|
CHECK(space_id, FAIL, "H5Screate_simple");
|
|
dset_id=H5Dcreate(grp1_id, string, H5T_NATIVE_INT, space_id, H5P_DEFAULT);
|
|
CHECK(dset_id, FAIL, "H5Dcreate");
|
|
|
|
/* Make sure that dataset can be opened again */
|
|
ret=H5Dclose(dset_id);
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
ret=H5Sclose(space_id);
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
dset_id=H5Dopen(grp1_id, string);
|
|
CHECK(ret, FAIL, "H5Dopen");
|
|
ret=H5Dclose(dset_id);
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
ret = H5Gclose(grp1_id);
|
|
CHECK(ret, FAIL, "H5Gclose");
|
|
|
|
/* Do the same for a named datatype */
|
|
grp2_id = H5Gcreate(fid, GROUP2_NAME, 0);
|
|
CHECK(grp2_id, FAIL, "H5Gcreate");
|
|
|
|
type_id = H5Tcreate(H5T_OPAQUE, 1);
|
|
CHECK(type_id, FAIL, "H5Tcreate");
|
|
ret = H5Tcommit(grp2_id, string, type_id);
|
|
CHECK(type_id, FAIL, "H5Tcommit");
|
|
ret = H5Tclose(type_id);
|
|
CHECK(type_id, FAIL, "H5Tclose");
|
|
|
|
type_id = H5Topen(grp2_id, string);
|
|
CHECK(type_id, FAIL, "H5Topen");
|
|
ret = H5Tclose(type_id);
|
|
CHECK(type_id, FAIL, "H5Tclose");
|
|
|
|
/* Don't close the group -- use it to test that object references
|
|
* can refer to objects named in UTF-8 */
|
|
|
|
space_id = H5Screate_simple(RANK, &dims, NULL);
|
|
CHECK(space_id, FAIL, "H5Screate_simple");
|
|
dset_id=H5Dcreate(grp2_id, DSET3_NAME, H5T_STD_REF_OBJ, space_id, H5P_DEFAULT);
|
|
CHECK(ret, FAIL, "H5Dcreate");
|
|
|
|
/* Create reference to named datatype */
|
|
ret = H5Rcreate(&obj_ref, grp2_id, string, H5R_OBJECT, -1);
|
|
CHECK(ret, FAIL, "H5Rcreate");
|
|
/* Write selection and read it back*/
|
|
ret = H5Dwrite(dset_id, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, &obj_ref);
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
ret = H5Dread(dset_id, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, &obj_ref);
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
/* Ensure that we can open named datatype using object reference */
|
|
type_id = H5Rdereference(dset_id, H5R_OBJECT, &obj_ref);
|
|
CHECK(type_id, FAIL, "H5Rdereference");
|
|
ret = H5Tcommitted(type_id);
|
|
VERIFY(ret, 1, "H5Tcommitted");
|
|
|
|
ret = H5Tclose(type_id);
|
|
CHECK(type_id, FAIL, "H5Tclose");
|
|
ret = H5Dclose(dset_id);
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
ret = H5Sclose(space_id);
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
ret = H5Gclose(grp2_id);
|
|
CHECK(ret, FAIL, "H5Gclose");
|
|
|
|
/* Create "group3". Build a hard link from group3 to group2, which has
|
|
* a datatype with the UTF-8 name. Create a soft link in group3
|
|
* pointing through the hard link to the datatype. Give the soft
|
|
* link a name in UTF-8. Ensure that the soft link works. */
|
|
|
|
grp3_id = H5Gcreate(fid, GROUP3_NAME, 0);
|
|
CHECK(grp3_id, FAIL, "H5Gcreate");
|
|
|
|
ret = H5Glink2(fid, GROUP2_NAME, H5G_LINK_HARD, grp3_id, GROUP2_NAME);
|
|
CHECK(ret, FAIL, "H5Glink2");
|
|
HDstrcpy(path_buf, GROUP2_NAME);
|
|
HDstrcat(path_buf, "/");
|
|
HDstrcat(path_buf, string);
|
|
ret = H5Glink(grp3_id, H5G_LINK_SOFT, path_buf, string);
|
|
CHECK(ret, FAIL, "H5Glink");
|
|
|
|
/* Open named datatype using soft link */
|
|
type_id = H5Topen(grp3_id, string);
|
|
CHECK(type_id, FAIL, "H5Topen");
|
|
|
|
ret = H5Tclose(type_id);
|
|
CHECK(type_id, FAIL, "H5Tclose");
|
|
ret = H5Gclose(grp3_id);
|
|
CHECK(ret, FAIL, "H5Gclose");
|
|
}
|
|
|
|
/*
|
|
* test_attrname
|
|
* Test that attributes can deal with UTF-8 strings
|
|
*/
|
|
void test_attrname(hid_t fid, const char * string)
|
|
{
|
|
hid_t group_id, attr_id;
|
|
hid_t dtype_id, space_id;
|
|
hsize_t dims=1;
|
|
char read_buf[MAX_STRING_LENGTH];
|
|
herr_t ret;
|
|
|
|
/* Create a new group and give it an attribute whose
|
|
* name and value are UTF-8 strings.
|
|
*/
|
|
group_id = H5Gcreate(fid, GROUP4_NAME, 0);
|
|
CHECK(group_id, FAIL, "H5Gcreate");
|
|
|
|
space_id = H5Screate_simple(RANK, &dims, NULL);
|
|
CHECK(space_id, FAIL, "H5Screate_simple");
|
|
dtype_id = H5Tcopy(H5T_C_S1);
|
|
CHECK(dtype_id, FAIL, "H5Tcopy");
|
|
ret=H5Tset_size(dtype_id, MAX_STRING_LENGTH);
|
|
CHECK(ret, FAIL, "H5Tset_size");
|
|
|
|
/* Create the attribute and check that its name is correct */
|
|
attr_id = H5Acreate(group_id, string, dtype_id, space_id, H5P_DEFAULT);
|
|
CHECK(attr_id, FAIL, "H5Acreate");
|
|
ret = H5Aget_name(attr_id, MAX_STRING_LENGTH, read_buf);
|
|
CHECK(ret, FAIL, "H5Aget_name");
|
|
ret = strcmp(read_buf, string);
|
|
VERIFY(ret, 0, "strcmp");
|
|
read_buf[0] = '\0';
|
|
|
|
/* Try writing and reading from the attribute */
|
|
ret = H5Awrite(attr_id, dtype_id, string);
|
|
CHECK(ret, FAIL, "H5Awrite");
|
|
ret = H5Aread(attr_id, dtype_id, read_buf);
|
|
CHECK(ret, FAIL, "H5Aread");
|
|
ret = strcmp(read_buf, string);
|
|
VERIFY(ret, 0, "strcmp");
|
|
|
|
/* Clean up */
|
|
ret = H5Aclose(attr_id);
|
|
CHECK(ret, FAIL, "H5Aclose");
|
|
ret = H5Tclose(dtype_id);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
ret = H5Sclose(space_id);
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
ret = H5Gclose(group_id);
|
|
CHECK(ret, FAIL, "H5Gclose");
|
|
}
|
|
|
|
/*
|
|
* test_attrname
|
|
* Test that compound datatypes can have UTF-8 field names.
|
|
*/
|
|
void test_compound(hid_t fid, const char * string)
|
|
{
|
|
/* Define two compound structures, s1_t and s2_t.
|
|
* s2_t is a subset of s1_t, with two out of three
|
|
* fields.
|
|
* This is stolen from the h5_compound example.
|
|
*/
|
|
typedef struct s1_t {
|
|
int a;
|
|
double c;
|
|
float b;
|
|
} s1_t;
|
|
typedef struct s2_t {
|
|
double c;
|
|
int a;
|
|
} s2_t;
|
|
/* Actual variable declarations */
|
|
s1_t s1;
|
|
s2_t s2;
|
|
hid_t s1_tid, s2_tid;
|
|
hid_t space_id, dset_id;
|
|
hsize_t dim = 1;
|
|
char *readbuf;
|
|
herr_t ret;
|
|
|
|
/* Initialize compound data */
|
|
HDmemset(&s1, 0, sizeof(s1_t)); /* To make purify happy */
|
|
s1.a = COMP_INT_VAL;
|
|
s1.c = COMP_DOUBLE_VAL;
|
|
s1.b = COMP_FLOAT_VAL;
|
|
|
|
/* Create compound datatypes using UTF-8 field name */
|
|
s1_tid = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
|
|
CHECK(s1_tid, FAIL, "H5Tcreate");
|
|
ret = H5Tinsert(s1_tid, string, HOFFSET(s1_t, a), H5T_NATIVE_INT);
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
|
|
|
/* Check that the field name was stored correctly */
|
|
readbuf=H5Tget_member_name(s1_tid, 0);
|
|
ret = strcmp(readbuf, string);
|
|
VERIFY(ret, 0, "strcmp");
|
|
free(readbuf);
|
|
|
|
/* Add the other fields to the datatype */
|
|
ret = H5Tinsert(s1_tid, "c_name", HOFFSET(s1_t, c), H5T_NATIVE_DOUBLE);
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
|
ret = H5Tinsert(s1_tid, "b_name", HOFFSET(s1_t, b), H5T_NATIVE_FLOAT);
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
|
|
|
/* Create second datatype, with only two fields. */
|
|
s2_tid = H5Tcreate (H5T_COMPOUND, sizeof(s2_t));
|
|
CHECK(s2_tid, FAIL, "H5Tcreate");
|
|
ret = H5Tinsert(s2_tid, "c_name", HOFFSET(s2_t, c), H5T_NATIVE_DOUBLE);
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
|
ret = H5Tinsert(s2_tid, string, HOFFSET(s2_t, a), H5T_NATIVE_INT);
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
|
|
|
/* Create the dataspace and dataset. */
|
|
space_id = H5Screate_simple(1, &dim, NULL);
|
|
CHECK(space_id, FAIL, "H5Screate_simple");
|
|
dset_id = H5Dcreate(fid, DSET4_NAME, s1_tid, space_id, H5P_DEFAULT);
|
|
CHECK(dset_id, FAIL, "H5Dcreate");
|
|
|
|
/* Write data to the dataset. */
|
|
ret = H5Dwrite(dset_id, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, &s1);
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
/* Ensure that data can be read back by field name into s2 struct */
|
|
ret = H5Dread(dset_id, s2_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, &s2);
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
VERIFY(s2.a, COMP_INT_VAL, "H5Dread");
|
|
VERIFY(s2.c, COMP_DOUBLE_VAL, "H5Dread");
|
|
|
|
/* Clean up */
|
|
ret = H5Tclose(s1_tid);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
ret = H5Tclose(s2_tid);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
ret = H5Sclose(space_id);
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
ret = H5Dclose(dset_id);
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
}
|
|
|
|
/*
|
|
* test_enum
|
|
* Test that enumerated datatypes can have UTF-8 member names.
|
|
*/
|
|
void test_enum(hid_t UNUSED fid, const char * string)
|
|
{
|
|
/* Define an enumerated type */
|
|
typedef enum {
|
|
E1_RED,
|
|
E1_GREEN,
|
|
E1_BLUE,
|
|
E1_WHITE
|
|
} c_e1;
|
|
/* Variable declarations */
|
|
c_e1 val;
|
|
herr_t ret;
|
|
hid_t type_id;
|
|
char readbuf[MAX_STRING_LENGTH];
|
|
|
|
/* Create an enumerated datatype in HDF5 with a UTF-8 member name*/
|
|
type_id = H5Tcreate(H5T_ENUM, sizeof(c_e1));
|
|
CHECK(type_id, FAIL, "H5Tcreate");
|
|
val = E1_RED;
|
|
ret = H5Tenum_insert(type_id, "RED", &val);
|
|
CHECK(ret, FAIL, "H5Tenum_insert");
|
|
val = E1_GREEN;
|
|
ret = H5Tenum_insert(type_id, "GREEN", &val);
|
|
CHECK(ret, FAIL, "H5Tenum_insert");
|
|
val = E1_BLUE;
|
|
ret = H5Tenum_insert(type_id, "BLUE", &val);
|
|
CHECK(ret, FAIL, "H5Tenum_insert");
|
|
val = E1_WHITE;
|
|
ret = H5Tenum_insert(type_id, string, &val);
|
|
CHECK(ret, FAIL, "H5Tenum_insert");
|
|
|
|
/* Ensure that UTF-8 member name gives the right value and vice versa. */
|
|
ret = H5Tenum_valueof(type_id, string, &val);
|
|
CHECK(ret, FAIL, "H5Tenum_valueof");
|
|
VERIFY(val, E1_WHITE, "H5Tenum_valueof");
|
|
ret = H5Tenum_nameof(type_id, &val, readbuf, MAX_STRING_LENGTH);
|
|
CHECK(ret, FAIL, "H5Tenum_nameof");
|
|
ret = strcmp(readbuf, string);
|
|
VERIFY(ret, 0, "strcmp");
|
|
|
|
/* Close the datatype */
|
|
ret = H5Tclose(type_id);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
}
|
|
|
|
/*
|
|
* test_opaque
|
|
* Test comments on opaque datatypes
|
|
*/
|
|
void test_opaque(hid_t UNUSED fid, const char * string)
|
|
{
|
|
hid_t type_id;
|
|
char * read_buf;
|
|
herr_t ret;
|
|
|
|
/* Create an opaque type and give it a UTF-8 tag */
|
|
type_id = H5Tcreate(H5T_OPAQUE, 4);
|
|
CHECK(type_id, FAIL, "H5Tcreate");
|
|
ret = H5Tset_tag(type_id, string);
|
|
CHECK(ret, FAIL, "H5Tset_tag");
|
|
|
|
/* Read the tag back. */
|
|
read_buf = H5Tget_tag(type_id);
|
|
ret = strcmp(read_buf, string);
|
|
VERIFY(ret, 0, "H5Tget_tag");
|
|
free(read_buf);
|
|
|
|
ret = H5Tclose(type_id);
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
}
|
|
|
|
/*********************/
|
|
/* Utility functions */
|
|
/*********************/
|
|
|
|
/* mkstr
|
|
* Borrwed from dtypes.c.
|
|
* Creates a new string data type. Used in string padding tests */
|
|
static hid_t mkstr(size_t len, H5T_str_t strpad)
|
|
{
|
|
hid_t t;
|
|
if ((t=H5Tcopy(H5T_C_S1))<0) return -1;
|
|
if (H5Tset_size(t, len)<0) return -1;
|
|
if (H5Tset_strpad(t, strpad)<0) return -1;
|
|
return t;
|
|
}
|
|
|
|
/* write_char
|
|
* Append a unicode code point c to test_string in UTF-8 encoding.
|
|
* Return the new end of the string.
|
|
*/
|
|
unsigned int write_char(unsigned int c, char * test_string, unsigned int cur_pos)
|
|
{
|
|
if (c < 0x80) {
|
|
test_string[cur_pos] = c;
|
|
cur_pos++;
|
|
}
|
|
else if (c < 0x800) {
|
|
test_string[cur_pos] = (0xC0 | c>>6);
|
|
test_string[cur_pos+1] = (0x80 | (c & 0x3F));
|
|
cur_pos += 2;
|
|
}
|
|
else if (c < 0x10000) {
|
|
test_string[cur_pos] = (0xE0 | c>>12);
|
|
test_string[cur_pos+1] = (0x80 | (c>>6 & 0x3F));
|
|
test_string[cur_pos+2] = (0x80 | (c & 0x3F));
|
|
cur_pos += 3;
|
|
}
|
|
else if (c < 0x200000) {
|
|
test_string[cur_pos] = (0xF0 | c>>18);
|
|
test_string[cur_pos+1] = (0x80 | (c>>12 & 0x3F));
|
|
test_string[cur_pos+2] = (0x80 | (c>>6 & 0x3F));
|
|
test_string[cur_pos+3] = (0x80 | (c & 0x3F));
|
|
cur_pos += 4;
|
|
}
|
|
|
|
return cur_pos;
|
|
}
|
|
|
|
/* dump_string
|
|
* Print a string both as text (which will look like garbage) and as hex.
|
|
* The text display is not guaranteed to be accurate--certain characters
|
|
* could confuse printf (e.g., '\n'). */
|
|
void dump_string(const char * string)
|
|
{
|
|
unsigned int length;
|
|
unsigned int x;
|
|
|
|
printf("The string was:\n");
|
|
printf(string);
|
|
printf("Or in hex:\n");
|
|
|
|
length = strlen(string);
|
|
|
|
for(x=0; x<length; x++)
|
|
printf("%x ", string[x] & (0x000000FF));
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
/* Main test.
|
|
* Create a string of random Unicode characters, then run each test with
|
|
* that string.
|
|
*/
|
|
void test_unicode(void)
|
|
{
|
|
char test_string[MAX_STRING_LENGTH];
|
|
unsigned int cur_pos=0; /* Current position in test_string */
|
|
unsigned int unicode_point; /* Unicode code point for a single character */
|
|
hid_t fid; /* ID of file */
|
|
int x; /* Temporary variable */
|
|
herr_t ret; /* Generic return value */
|
|
|
|
/* Output message about test being performed */
|
|
MESSAGE(5, ("Testing UTF-8 Encoding\n"));
|
|
|
|
/* Create a random string with length NUM_CHARS */
|
|
HDsrandom((unsigned long)HDtime(NULL));
|
|
|
|
HDmemset(test_string, 0, sizeof(test_string));
|
|
for(x=0; x<NUM_CHARS; x++)
|
|
{
|
|
/* We need to avoid unprintable characters (codes 0-31) and the
|
|
* . and / characters, since they aren't allowed in path names.
|
|
*/
|
|
unicode_point = (HDrandom() % (MAX_CODE_POINT-32)) + 32;
|
|
if(unicode_point != 46 && unicode_point != 47)
|
|
cur_pos = write_char(unicode_point, test_string, cur_pos);
|
|
}
|
|
|
|
/* Avoid unlikely case of the null string */
|
|
if(cur_pos == 0)
|
|
{
|
|
test_string[cur_pos] = 'Q';
|
|
cur_pos++;
|
|
}
|
|
test_string[cur_pos]='\0';
|
|
|
|
/* Create file */
|
|
fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
|
|
CHECK(fid, FAIL, "H5Fcreate");
|
|
|
|
test_fl_string(fid, test_string);
|
|
test_strpad(fid, "abcdefgh");
|
|
test_strpad(fid, test_string);
|
|
test_vl_string(fid, test_string);
|
|
test_objnames(fid, test_string);
|
|
test_attrname(fid, test_string);
|
|
test_compound(fid, test_string);
|
|
test_enum(fid, test_string);
|
|
test_opaque(fid, test_string);
|
|
|
|
/* Close file */
|
|
ret = H5Fclose(fid);
|
|
CHECK(ret, FAIL, "H5Fclose");
|
|
|
|
/* This function could be useful in debugging if certain strings
|
|
* create errors.
|
|
*/
|
|
#ifdef DEBUG
|
|
dump_string(test_string);
|
|
#endif /* DEBUG */
|
|
}
|
|
|
|
/* cleanup_unicode(void)
|
|
* Delete the file this test created.
|
|
*/
|
|
void cleanup_unicode(void)
|
|
{
|
|
remove(FILENAME);
|
|
}
|
|
|
|
|