diff options
Diffstat (limited to 'c++/test/ttypes.cpp')
-rw-r--r-- | c++/test/ttypes.cpp | 810 |
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]); +} |