summaryrefslogtreecommitdiffstats
path: root/c++/test/ttypes.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'c++/test/ttypes.cpp')
-rw-r--r--c++/test/ttypes.cpp810
1 files changed, 810 insertions, 0 deletions
diff --git a/c++/test/ttypes.cpp b/c++/test/ttypes.cpp
new file mode 100644
index 0000000..906ed23
--- /dev/null
+++ b/c++/test/ttypes.cpp
@@ -0,0 +1,810 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group (THG). *
+ * 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://www.hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
+ * access to either file, you may request a copy from help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*****************************************************************************
+ FILE
+ ttypes.cpp - HDF5 C++ testing the general data type functionality
+
+ ***************************************************************************/
+
+#ifdef OLD_HEADER_FILENAME
+#include <iostream.h>
+#else
+#include <iostream>
+#endif
+#include <string>
+
+#ifndef H5_NO_NAMESPACE
+#ifndef H5_NO_STD
+ using std::cerr;
+ using std::endl;
+#endif // H5_NO_STD
+#endif
+
+#include "testhdf5.h" // C test header file
+#include "H5Cpp.h" // C++ API header file
+
+#ifndef H5_NO_NAMESPACE
+ using namespace H5;
+#endif
+
+#include "h5cpputil.h" // C++ utilility header file
+
+const H5std_string DATAFILE("ttypes.h5");
+
+#define NTESTS 1
+
+/* Number of elements in each test */
+#define NTESTELEM 100000
+
+/* Define if you want to see a count of overflows */
+#undef SHOW_OVERFLOWS
+
+/*
+ * Offset from alinged memory returned by malloc(). This can be used to test
+ * that type conversions handle non-aligned buffers correctly.
+ */
+#define ALIGNMENT 1
+
+/*
+ * Define if you want to test alignment code on a machine that doesn't
+ * normally require alignment. When set, all native data types must be aligned
+ * on a byte boundary equal to the data size.
+ */
+#define TEST_ALIGNMENT
+
+/* Alignment test stuff */
+#ifdef TEST_ALIGNMENT
+#define H5T_PACKAGE
+#include "H5Tpkg.h"
+#endif
+#define SET_ALIGNMENT(TYPE,VAL) \
+ H5T_NATIVE_##TYPE##_ALIGN_g=MAX(H5T_NATIVE_##TYPE##_ALIGN_g, VAL)
+
+const char *FILENAME[] = {
+ "dtypes1.h5",
+ "dtypes2.h5",
+ "dtypes3.h5",
+ NULL
+};
+
+/*
+ * Count up or down depending on whether the machine is big endian or little
+ * endian. If local variable `endian' is H5T_ORDER_BE then the result will
+ * be I, otherwise the result will be Z-(I+1).
+ */
+#define ENDIAN(Z,I) (H5T_ORDER_BE==endian?(I):(Z)-((I)+1))
+
+
+typedef enum flt_t {
+ FLT_FLOAT, FLT_DOUBLE, FLT_LDOUBLE, FLT_OTHER
+} flt_t;
+
+typedef enum int_t {
+ INT_CHAR, INT_UCHAR, INT_SHORT, INT_USHORT, INT_INT, INT_UINT,
+ INT_LONG, INT_ULONG, INT_LLONG, INT_ULLONG, INT_OTHER
+} int_t;
+
+/* Count the number of overflows */
+#ifdef SHOW_OVERFLOWS
+static int noverflows_g = 0;
+#endif
+
+/* Skip overflow tests if non-zero */
+static int skip_overflow_tests_g = 0;
+
+/* Don't use hardware conversions if set */
+static int without_hardware_g = 0;
+
+/* Count opaque conversions */
+static int num_opaque_conversions_g = 0;
+
+/*
+ * Although we check whether a floating point overflow generates a SIGFPE and
+ * turn off overflow tests in that case, it might still be possible for an
+ * overflow condition to occur. Once a SIGFPE is raised the program cannot
+ * be allowed to continue (cf. Posix signals) so in order to recover from a
+ * SIGFPE we run tests that might generate one in a child process.
+ */
+#if defined(H5_HAVE_FORK) && defined(H5_HAVE_WAITPID)
+# define HANDLE_SIGFPE
+#endif
+
+/* Allocates memory aligned on a certain boundary. */
+#define aligned_malloc(Z) ((void*)((char*)malloc(ALIGNMENT+Z)+ALIGNMENT))
+#define aligned_free(M) free((char*)(M)-ALIGNMENT)
+
+
+/*-------------------------------------------------------------------------
+ * Function: fpe_handler
+ *
+ * Purpose: Exit with 255
+ *
+ * Return: void
+ *
+ * Programmer: Robb Matzke
+ * Monday, July 6, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+fpe_handler(int UNUSED signo)
+{
+ SKIPPED();
+ puts(" Test skipped due to SIGFPE.");
+#ifndef HANDLE_SIGFPE
+ puts(" Remaining tests could not be run.");
+ puts(" Please turn off SIGFPE on overflows and try again.");
+#endif
+ exit(255);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: overflow_handler
+ *
+ * Purpose: Gets called for all data type conversion overflows.
+ *
+ * Return: Success: 0
+ *
+ * Failure: -1
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, July 7, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifdef SHOW_OVERFLOWS
+static herr_t
+overflow_handler(hid_t UNUSED src_id, hid_t UNUSED dst_id,
+ void UNUSED *src_buf, void UNUSED *dst_buf)
+{
+ noverflows_g++;
+ return -1;
+}
+#endif
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_classes
+ *
+ * Purpose: Test type classes
+ *
+ * Return: Success: 0
+ *
+ * Failure: number of errors
+ *
+ * Programmer: Binh-Minh Ribler (using C version)
+ * January, 2007
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void test_classes(void)
+{
+ SUBTEST("PredType::getClass()");
+ try {
+ // PredType::NATIVE_INT should be in H5T_INTEGER class
+ H5T_class_t tcls = PredType::NATIVE_INT.getClass();
+ if (H5T_INTEGER!=tcls) {
+ H5_FAILED();
+ puts(" Invalid type class for H5T_NATIVE_INT");
+ }
+
+ // PredType::NATIVE_DOUBLE should be in H5T_FLOAT class
+ tcls = PredType::NATIVE_DOUBLE.getClass();
+ if (H5T_FLOAT!=tcls) {
+ H5_FAILED();
+ puts(" Invalid type class for H5T_NATIVE_DOUBLE");
+ }
+ PASSED();
+ } // end of try block
+ catch (DataTypeIException E) {
+ issue_fail_msg(E.getCFuncName(), __LINE__, __FILE__, E.getCDetailMsg());
+ }
+}
+
+/*-------------------------------------------------------------------------
+ * Function: test_copy
+ *
+ * Purpose: Test datatype copy functionality
+ *
+ * Return: Success: 0
+ *
+ * Failure: number of errors
+ *
+ * Programmer: Binh-Minh Ribler (using C version)
+ * January, 2007
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void test_copy(void)
+{
+ hid_t a_copy;
+ herr_t status;
+
+ //MESSAGE(5, ("DataType::copy() and DataType::operator="));
+ SUBTEST("DataType::copy() and DataType::operator=");
+ try {
+ // Test copying from a predefined datatype using DataType::operator=
+ DataType assigned_type;
+ assigned_type = PredType::NATIVE_SHORT;
+
+ // Test copying a predefined type using DataType::copy
+ DataType copied_type;
+ copied_type.copy (PredType::STD_B8LE);
+
+ // Test copying a user-defined type using DataType::operator=
+ DataType assigned_usertype;
+ assigned_usertype = copied_type;
+
+ // Test copying from a user-defined datatype using DataType::copy
+ DataType copied_usertype;
+ copied_usertype.copy(copied_type);
+
+ // Test copying a user-defined int type using DataType::operator=
+ IntType orig_int(PredType::STD_B8LE);
+ DataType generic_type;
+ generic_type = orig_int;
+
+ // Test copying an integer predefined type
+ IntType new_int_type(PredType::STD_B8LE);
+
+ // Test copying an int predefined type using DataType::operator=
+ IntType another_int_type;
+ another_int_type = new_int_type;
+
+ PASSED();
+ }
+ catch (DataTypeIException E) {
+ issue_fail_msg(E.getCFuncName(), __LINE__, __FILE__, E.getCDetailMsg());
+ }
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_query
+ *
+ * Purpose: Tests query functions of compound and enumeration types.
+ *
+ * Return: Success: 0
+ *
+ * Failure: number of errors
+ *
+ * Programmer: Binh-Minh Ribler (use C version)
+ * January, 2007
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+
+const H5std_string CompT_NAME("Compound_type");
+const H5std_string EnumT_NAME("Enum_type");
+
+static void test_query(void)
+{
+ typedef struct {
+ int a;
+ float b;
+ long c;
+ double d;
+ } s_type_t;
+ char filename[1024];
+ short enum_val;
+
+ // Output message about test being performed
+ SUBTEST("Query functions of compound and enumeration types");
+ try
+ {
+ /* Create File */
+ H5File file(FILENAME[2], H5F_ACC_TRUNC);
+
+ /* Create a compound datatype */
+ CompType tid1(sizeof(s_type_t));
+
+ tid1.insertMember("a", HOFFSET(s_type_t, a), PredType::NATIVE_INT);
+ tid1.insertMember("b", HOFFSET(s_type_t, b), PredType::NATIVE_FLOAT);
+ tid1.insertMember("c", HOFFSET(s_type_t, c), PredType::NATIVE_LONG);
+ tid1.insertMember("d", HOFFSET(s_type_t, d), PredType::NATIVE_DOUBLE);
+
+ /* Create a enumerate datatype */
+ EnumType tid2(sizeof(short));
+
+ tid2.insert("RED", (enum_val=0,&enum_val));
+ tid2.insert("GREEN", (enum_val=1,&enum_val));
+ tid2.insert("BLUE", (enum_val=2,&enum_val));
+ tid2.insert("ORANGE", (enum_val=3,&enum_val));
+ tid2.insert("YELLOW", (enum_val=4,&enum_val));
+
+ /* Query member number and member index by name, for compound type */
+ int nmembs = tid1.getNmembers();
+ verify_val(nmembs, 4, "CompType::getNmembers()", __LINE__, __FILE__);
+
+ int index = tid1.getMemberIndex("c");
+ verify_val(index, 2, "CompType::getMemberIndex()", __LINE__, __FILE__);
+
+ /* Query member number and member index by name, for enumeration type. */
+ nmembs = tid2.getNmembers();
+ verify_val(nmembs, 5, "EnumType::getNmembers()", __LINE__, __FILE__);
+
+ index = tid2.getMemberIndex("ORANGE");
+ verify_val(index, 3, "EnumType::getMemberIndex()", __LINE__, __FILE__);
+
+ /* Commit compound datatype and close it */
+ tid1.commit(file, CompT_NAME);
+ tid1.close();
+
+ /* Commit enumeration datatype and close it */
+ tid2.commit(file, EnumT_NAME);
+ tid2.close();
+
+ /* Open the datatype for query */
+ tid1 = file.openCompType(CompT_NAME);
+
+ tid2 = file.openEnumType(EnumT_NAME);
+
+ /* Query member number and member index by name, for compound type */
+ nmembs = tid1.getNmembers();
+ verify_val(nmembs, 4, "CompType::getNmembers()", __LINE__, __FILE__);
+
+ index = tid1.getMemberIndex("c");
+ verify_val(index, 2, "CompType::getMemberIndex()", __LINE__, __FILE__);
+
+ /* Query member number and member index by name, for enumeration type */
+ nmembs = tid2.getNmembers();
+ verify_val(nmembs, 5, "EnumType::getNmembers()", __LINE__, __FILE__);
+
+ index = tid2.getMemberIndex("ORANGE");
+ verify_val(index, 3, "EnumType::getMemberIndex()", __LINE__, __FILE__);
+
+ /* Close data types and file */
+ tid1.close();
+ tid2.close();
+ file.close();
+
+ PASSED();
+ } // end of try block
+ catch (Exception E) {
+ issue_fail_msg(E.getCFuncName(), __LINE__, __FILE__, E.getCDetailMsg());
+ }
+} // test_query
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_transient
+ *
+ * Purpose: Tests transient data types.
+ *
+ * Return: Success: 0
+ *
+ * Failure: number of errors
+ *
+ * Programmer: Binh-Minh Ribler (use C version)
+ * January, 2007
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+const char* filename1("dtypes1.h5");
+static void test_transient ()
+{
+ static hsize_t ds_size[2] = {10, 20};
+
+ //MESSAGE(5, ("transient data types"));
+ SUBTEST("Transient data types");
+ try {
+
+ H5File file(filename1, H5F_ACC_TRUNC);
+ DataSpace space(2, ds_size, ds_size);
+
+ /* Predefined types cannot be modified or closed */
+// PredType::NATIVE_INT is a constant and cannot make a call, don't need these tests
+
+ /* Copying a predefined type results in a modifiable copy */
+ IntType type(PredType::NATIVE_INT);
+ type.setPrecision(256);
+
+ /* It should not be possible to create an attribute for a transient type */
+ try {
+ Attribute attr(type.createAttribute("attr1", PredType::NATIVE_INT, space));
+ // Should FAIL but didn't, so throw an invalid action exception
+ throw InvalidActionException("H5Object::createAttribute", "Attempted to commit a predefined datatype.");
+ } catch (AttributeIException err) {}
+
+ /* Create a dataset from a transient data type */
+// type.close(); - put printf in H5Tclose to make sure it's closed
+ type.copy(PredType::NATIVE_INT);
+ DataSet dset(file.createDataSet("dset1", type, space));
+
+ /* The type returned from a dataset should not be modifiable */
+ IntType itype(dset);
+ try {
+ itype.setPrecision(256);
+
+ // Should FAIL but didn't, so throw an invalid action exception
+ throw InvalidActionException("PredType::setPrecision", "Dataset data types should not be modifiable!");
+ } catch (DataTypeIException err) {}
+
+ itype.close();
+
+ /*
+ * Get the dataset data type by applying H5Tcopy() to the dataset. The
+ * result should be modifiable.
+ */
+ itype.copy(dset);
+ itype.setPrecision(256);
+
+ /*
+ * Close the dataset and reopen it, testing that its type is still
+ * read-only. <--- how come modifiable below?
+ */
+ dset.close();
+ //if (H5Dclose (dset)<0) printf("goto error in C\n");
+ dset = file.openDataSet("dset1");
+ //if ((dset=H5Dopen (file, "dset1"))<0) printf("goto error in C\n");
+
+ /*
+ * Get the dataset data type by applying H5Tcopy() to the dataset. The
+ * result should be modifiable.
+ */
+ itype.copy(dset);
+ itype.setPrecision(256);
+ itype.close();
+
+ // Close objects and file.
+ dset.close();
+ file.close();
+ type.close();
+ space.close();
+ PASSED();
+ } // end of try block
+ catch (Exception E) {
+ issue_fail_msg(E.getCFuncName(), __LINE__, __FILE__, E.getCDetailMsg());
+ }
+} // test_transient
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_named
+ *
+ * Purpose: Tests named data types.
+ *
+ * Return: Success: 0
+ *
+ * Failure: number of errors
+ *
+ * Programmer: Binh-Minh Ribler (use C version)
+ * January, 2007
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+const H5std_string filename2("dtypes2.h5");
+static void test_named ()
+{
+ herr_t status;
+ static hsize_t ds_size[2] = {10, 20};
+ hsize_t i;
+ unsigned attr_data[10][20];
+ char filename[1024];
+
+ //MESSAGE(5, ("named data types"));
+ SUBTEST("Named data types");
+ try {
+
+// h5_fixname(FILENAME[1], fapl_id, filename, sizeof filename);
+ H5File file(filename2, H5F_ACC_TRUNC);
+
+ DataSpace space(2, ds_size, ds_size);
+
+ /* Predefined types cannot be committed */
+ try {
+PredType nativeint(PredType::NATIVE_INT);
+nativeint.commit(file, "test_named_1 (should not exist)");
+ //PredType::NATIVE_INT.commit(file, "test_named_1 (should not exist)");
+ // Should FAIL but didn't, so throw an invalid action exception
+ throw InvalidActionException("PredType::commit", "Attempted to commit a predefined datatype.");
+ } catch (DataTypeIException err) {}
+
+/*
+ H5E_BEGIN_TRY {
+ status = H5Tcommit (file, "test_named_1 (should not exist)",
+ H5T_NATIVE_INT);
+ } H5E_END_TRY;
+ if (status>=0) {
+ H5_FAILED();
+ puts (" Predefined types should not be committable!");
+ printf("goto error in C\n");
+ }
+*/
+
+ /* Copy a predefined data type and commit the copy */
+ IntType itype(PredType::NATIVE_INT);
+ //if ((type = H5Tcopy (H5T_NATIVE_INT))<0) printf("goto error in C\n");
+
+ itype.commit(file, "native-int");
+ //if (H5Tcommit (file, "native-int", type)<0) printf("goto error in C\n");0,
+
+ if (itype.committed() <= 0)
+ cerr << "IntType::committed() returned false" << endl;
+
+/*
+ if ((status=H5Tcommitted (type))<0) printf("goto error in C\n");
+ if (0==status) {
+ H5_FAILED();
+ puts (" H5Tcommitted() returned false!");
+ printf("goto error in C\n");
+ }
+*/
+
+ /* We should not be able to modify a type after it has been committed. */
+ try {
+ itype.setPrecision(256);
+
+ // Should FAIL but didn't, so throw an invalid action exception
+ throw InvalidActionException("IntType::setPrecision", "Attempted to modify a committed datatype.");
+ } catch (DataTypeIException err) {}
+
+/*
+ H5E_BEGIN_TRY {
+ status = H5Tset_precision (type, 256);
+ } H5E_END_TRY;
+ if (status>=0) {
+ H5_FAILED();
+ puts (" Committed type is not constant!");
+ printf("goto error in C\n");
+ }
+*/
+ /* We should not be able to re-commit a committed type */
+ try {
+ itype.commit(file, "test_named_2 (should not exist)");
+
+ // Should FAIL but didn't, so throw an invalid action exception
+ throw InvalidActionException("IntType::commit", "Attempted to re-commit a committed data type.");
+ } catch (DataTypeIException err) {}
+
+/*
+ H5E_BEGIN_TRY {
+ status = H5Tcommit(file, "test_named_2 (should not exist)", type);
+ } H5E_END_TRY;
+ if (status>=0) {
+ H5_FAILED();
+ puts (" Committed types should not be recommitted!");
+ printf("goto error in C\n");
+ }
+*/
+
+ /* It should be possible to define an attribute for the named type */
+ Attribute attr1 = itype.createAttribute("attr1", PredType::NATIVE_UCHAR, space);
+ //if ((attr1=H5Acreate (type, "attr1", H5T_NATIVE_UCHAR, space,
+// H5P_DEFAULT))<0) printf("goto error in C\n");
+
+
+ for (i=0; i<ds_size[0]*ds_size[1]; i++) attr_data[0][i] = (int)i;/*tricky*/
+
+ attr1.write(PredType::NATIVE_UINT, attr_data);
+ attr1.close();
+ //if (H5Awrite(attr1, H5T_NATIVE_UINT, attr_data)<0) printf("goto error in C\n");
+ //if (H5Aclose (attr1)<0) printf("goto error in C\n");
+
+ /*
+ * Copying a committed type should result in a transient type which is
+ * not locked.
+ */
+ IntType trans_type;
+ trans_type.copy(itype);
+ bool iscommitted = trans_type.committed();
+ verify_val(iscommitted, 0, "DataType::committed() - Copying a named type should result in a transient type!", __LINE__, __FILE__);
+/*
+ if ((t2 = H5Tcopy (type))<0) printf("goto error in C\n");
+ if ((status=H5Tcommitted (t2))<0) printf("goto error in C\n");
+ if (status) {
+ H5_FAILED();
+ puts (" Copying a named type should result in a transient type!");
+ printf("goto error in C\n");
+ }
+*/
+ trans_type.setPrecision(256);
+ trans_type.close();
+ //if (H5Tset_precision (t2, 256)<0) printf("goto error in C\n");
+ //if (H5Tclose (t2)<0) printf("goto error in C\n");
+
+ /*
+ * Close the committed type and reopen it. It should return a named type.
+ */
+/* This had something to do with the way IntType was returned and assigned
+and caused itype.committed not working correctly. So, use another_type for
+now.
+ itype = file.openIntType("native-int");
+ iscommitted = itype.committed();
+*/
+ IntType another_type = file.openIntType("native-int");
+ iscommitted = another_type.committed();
+ if (!iscommitted)
+ throw InvalidActionException("IntType::committed()", "Opened named types should be named types!");
+
+/*
+ if (H5Tclose (type)<0) printf("goto error in C\n");
+ if ((type=H5Topen (file, "native-int"))<0) printf("goto error in C\n");
+ if ((status=H5Tcommitted (type))<0) printf("goto error in C\n");
+ if (!status) {
+ H5_FAILED();
+ puts (" Opened named types should be named types!");
+ printf("goto error in C\n");
+ }
+ */
+ /* Create a dataset that uses the named type */
+ DataSet dset = file.createDataSet("dset1", itype, space);
+ //if ((dset = H5Dcreate (file, "dset1", type, space, H5P_DEFAULT))<0)
+
+ /* Get the dataset's data type and make sure it's a named type */
+ DataType *ds_type = new DataType(dset.getDataType());
+ iscommitted = ds_type->committed();
+ if (!iscommitted)
+ throw InvalidActionException("IntType::committed()", "1 Dataset type should be named type!");
+
+/*
+ if ((t2 = H5Dget_type (dset))<0) printf("goto error in C\n");
+ if ((status=H5Tcommitted (t2))<0) printf("goto error in C\n");
+ if (!status) {
+ H5_FAILED();
+ puts (" Dataset type should be a named type!");
+ printf("goto error in C\n");
+ }
+*/
+
+ /* Close the dataset, then close its type, then reopen the dataset */
+ dset.close();
+ ds_type->close();
+ //if (H5Dclose (dset)<0) printf("goto error in C\n");
+ //if (H5Tclose (t2)<0) printf("goto error in C\n");
+
+ dset = file.openDataSet("dset1");
+ //if ((dset = H5Dopen (file, "dset1"))<0) printf("goto error in C\n");
+
+ /* Get the dataset's type and make sure it's named */
+ /* Get the dataset's data type and make sure it's a named type */
+ ds_type = new DataType(dset.getDataType());
+ iscommitted = ds_type->committed();
+ if (!iscommitted)
+ throw InvalidActionException("IntType::committed()", "Dataset type should be named type!");
+/*
+ if ((t2 = H5Dget_type (dset))<0) printf("goto error in C\n");
+ if ((status=H5Tcommitted (t2))<0) printf("goto error in C\n");
+ if (!status) {
+ H5_FAILED();
+ puts (" Dataset type should be a named type!");
+ printf("goto error in C\n");
+ }
+*/
+
+ /*
+ * Close the dataset and create another with the type returned from the
+ * first dataset.
+ */
+ dset.close();
+ //if (H5Dclose (dset)<0) printf("goto error in C\n");
+ dset = file.createDataSet("dset2", *ds_type, space);
+ //if ((dset=H5Dcreate (file, "dset2", t2, space, H5P_DEFAULT))<0)
+
+ /* Reopen the second dataset and make sure the type is shared */
+ ds_type->close();
+ dset.close();
+ dset = file.openDataSet("dset2");
+ ds_type = new DataType(dset.getDataType());
+ iscommitted = ds_type->committed();
+ if (!iscommitted)
+ throw InvalidActionException("IntType::committed()", "Dataset type should be named type!");
+
+/*
+ if (H5Tclose (t2)<0) printf("goto error in C\n");
+ if (H5Dclose (dset)<0) printf("goto error in C\n");
+ if ((dset = H5Dopen (file, "dset2"))<0) printf("goto error in C\n");
+ if ((t2 = H5Dget_type (dset))<0) printf("goto error in C\n");
+ if ((status=H5Tcommitted (t2))<0) printf("goto error in C\n");
+ if (!status) {
+ H5_FAILED();
+ puts (" Dataset type should be a named type!");
+ printf("goto error in C\n");
+ }
+*/
+ ds_type->close();
+ //if (H5Tclose (t2)<0) printf("goto error in C\n");
+
+ /*
+ * Get the dataset data type by applying H5Tcopy() to the dataset. The
+ * result should be modifiable.
+ */
+ //DataType copied_type = dset.copyType();
+ IntType copied_type;
+ copied_type.copy(dset);
+ //if ((t2=H5Tcopy (dset))<0) printf("goto error in C\n");
+
+// find another function that can be in DataType
+ copied_type.setPrecision(256);
+// if (H5Tset_precision (t2, 256)<0) printf("goto error in C\n");
+ //copied_type.close();
+ copied_type.close();
+ //if (H5Tclose (t2)<0) printf("goto error in C\n");
+
+ /* Clean up */
+ dset.close();
+ itype.close();
+ space.close();
+ file.close();
+/*
+ if (H5Dclose (dset)<0) printf("goto error in C\n");
+ if (H5Tclose (type)<0) printf("goto error in C\n");
+ if (H5Sclose (space)<0) printf("goto error in C\n");
+ if (H5Fclose (file)<0) printf("goto error in C\n");
+*/
+ PASSED();
+ } // end of try block
+ catch (Exception E) {
+cerr << "all the way here?" << endl;
+ issue_fail_msg(E.getCFuncName(), __LINE__, __FILE__, E.getCDetailMsg());
+ }
+} // test_named
+
+
+/****************************************************************
+**
+** test_types(): Main data types testing routine.
+**
+****************************************************************/
+void test_types(void)
+{
+ // Output message about test being performed
+ MESSAGE(5, ("Testing Generic Data Types\n"));
+
+ // Test basic datatypes
+ test_classes();
+ test_copy();
+ test_query();
+ test_transient();
+ test_named();
+
+} // test_types()
+
+
+/*-------------------------------------------------------------------------
+ * Function: cleanup_types
+ *
+ * Purpose: Cleanup temporary test files
+ *
+ * Return: none
+ *
+ * Programmer: Quincey Koziol
+ * September 10, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+cleanup_types(void)
+{
+ for (int i = 0; i < 3; i++)
+ HDremove(FILENAME[i]);
+}
generated by cgit v0.12 at 2024-07-18 19:44:25 (GMT)