2004-01-07 01:53:13 +08:00
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
2007-02-07 22:56:24 +08:00
|
|
|
|
* Copyright by The HDF Group. *
|
2004-01-07 01:53:13 +08:00
|
|
|
|
* 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 *
|
2007-02-07 22:56:24 +08:00
|
|
|
|
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
|
|
|
|
|
* access to either file, you may request a copy from help@hdfgroup.org. *
|
2004-01-07 01:53:13 +08:00
|
|
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Programmer: Quincey Koziol <koziol@ncsa.uiuc.edu>
|
|
|
|
|
* Tuesday, January 6, 2004
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Provides support functions for the testing framework.
|
2005-08-14 04:53:35 +08:00
|
|
|
|
*
|
2004-01-07 01:53:13 +08:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "testhdf5.h"
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Definitions for the testing structure.
|
|
|
|
|
*/
|
|
|
|
|
#define MAXTESTNAME 16
|
2016-07-19 06:36:44 +08:00
|
|
|
|
#define MAXTESTDESC 64
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
|
|
|
|
typedef struct TestStruct {
|
|
|
|
|
int NumErrors;
|
|
|
|
|
char Description[MAXTESTDESC];
|
|
|
|
|
int SkipFlag;
|
|
|
|
|
char Name[MAXTESTNAME];
|
|
|
|
|
void (*Call)(void);
|
|
|
|
|
void (*Cleanup)(void);
|
2004-08-08 10:26:44 +08:00
|
|
|
|
const void *Parameters;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
} TestStruct;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2004-01-10 09:41:13 +08:00
|
|
|
|
* Variables used by testing framework.
|
2004-01-07 01:53:13 +08:00
|
|
|
|
*/
|
2004-01-10 09:41:13 +08:00
|
|
|
|
static int num_errs = 0; /* Total number of errors during testing */
|
2010-01-23 05:17:48 +08:00
|
|
|
|
int TestVerbosity = VERBO_DEF; /* Default Verbosity is Low */
|
2004-08-19 14:32:47 +08:00
|
|
|
|
static int Summary = 0; /* Show test summary. Default is no. */
|
|
|
|
|
static int CleanUp = 1; /* Do cleanup or not. Default is yes. */
|
2006-04-07 23:34:40 +08:00
|
|
|
|
static int TestExpress = -1; /* Do TestExpress or not. -1 means not set yet. */
|
2016-07-19 06:36:44 +08:00
|
|
|
|
static TestStruct *Test = NULL; /* Array of tests */
|
|
|
|
|
static unsigned TestAlloc = 0; /* Size of the Test array */
|
|
|
|
|
static unsigned Index = 0;
|
2004-08-08 10:26:44 +08:00
|
|
|
|
static const void *Test_parameters = NULL;
|
2004-08-19 14:32:47 +08:00
|
|
|
|
static const char *TestProgName = NULL;
|
|
|
|
|
static void (*TestPrivateUsage)(void) = NULL;
|
|
|
|
|
static int (*TestPrivateParser)(int ac, char *av[]) = NULL;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Setup a test function and add it to the list of tests.
|
|
|
|
|
* It must have no parameters and returns void.
|
2004-08-08 10:26:44 +08:00
|
|
|
|
* TheName--short test name.
|
|
|
|
|
* If the name starts with '-', do not run it by default.
|
|
|
|
|
* TheCall--the test routine.
|
|
|
|
|
* Cleanup--the cleanup routine for the test.
|
|
|
|
|
* TheDescr--Long description of the test.
|
2004-03-31 07:35:16 +08:00
|
|
|
|
* Parameters--pointer to extra parameters. Use NULL if none used.
|
|
|
|
|
* Since only the pointer is copied, the contents should not change.
|
2014-07-23 03:06:18 +08:00
|
|
|
|
* Return: Void
|
|
|
|
|
* exit EXIT_FAILURE if error is encountered.
|
2004-01-07 01:53:13 +08:00
|
|
|
|
*/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
void
|
2004-03-31 07:35:16 +08:00
|
|
|
|
AddTest(const char *TheName, void (*TheCall) (void), void (*Cleanup) (void), const char *TheDescr, const void *Parameters)
|
2004-01-07 01:53:13 +08:00
|
|
|
|
{
|
|
|
|
|
/* Sanity checking */
|
|
|
|
|
if (HDstrlen(TheDescr) >= MAXTESTDESC) {
|
2016-07-19 06:36:44 +08:00
|
|
|
|
printf("Test description ('%s') too long, increase MAXTESTDESC(%d).\n",
|
|
|
|
|
TheDescr, MAXTESTDESC);
|
2014-07-23 03:06:18 +08:00
|
|
|
|
exit(EXIT_FAILURE);
|
2004-01-07 01:53:13 +08:00
|
|
|
|
} /* end if */
|
|
|
|
|
if (HDstrlen(TheName) >= MAXTESTNAME) {
|
|
|
|
|
printf("Test name too long, increase MAXTESTNAME(%d).\n",
|
|
|
|
|
MAXTESTNAME);
|
2014-07-23 03:06:18 +08:00
|
|
|
|
exit(EXIT_FAILURE);
|
2004-01-07 01:53:13 +08:00
|
|
|
|
} /* end if */
|
|
|
|
|
|
2016-07-19 06:36:44 +08:00
|
|
|
|
/* Check for increasing the Test array size */
|
|
|
|
|
if(Index >= TestAlloc) {
|
|
|
|
|
TestStruct *newTest = Test; /* New array of tests */
|
|
|
|
|
unsigned newAlloc = MAX(1, TestAlloc * 2); /* New array size */
|
|
|
|
|
|
|
|
|
|
/* Reallocate array */
|
|
|
|
|
if(NULL == (newTest = (TestStruct *)HDrealloc(Test, newAlloc * sizeof(TestStruct)))) {
|
|
|
|
|
printf("Out of memory for tests, Index = %u, TestAlloc = %u, newAlloc = %u\n", Index, TestAlloc, newAlloc);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
|
|
|
|
/* Update info */
|
|
|
|
|
Test = newTest;
|
|
|
|
|
TestAlloc = newAlloc;
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
2004-01-07 01:53:13 +08:00
|
|
|
|
/* Set up test function */
|
|
|
|
|
HDstrcpy(Test[Index].Description, TheDescr);
|
2016-07-19 06:36:44 +08:00
|
|
|
|
if(*TheName != '-') {
|
2004-08-08 10:26:44 +08:00
|
|
|
|
HDstrcpy(Test[Index].Name, TheName);
|
|
|
|
|
Test[Index].SkipFlag = 0;
|
|
|
|
|
}
|
|
|
|
|
else { /* skip test by default */
|
|
|
|
|
HDstrcpy(Test[Index].Name, TheName+1);
|
|
|
|
|
Test[Index].SkipFlag = 1;
|
|
|
|
|
}
|
2004-01-07 01:53:13 +08:00
|
|
|
|
Test[Index].Call = TheCall;
|
|
|
|
|
Test[Index].Cleanup = Cleanup;
|
|
|
|
|
Test[Index].NumErrors = -1;
|
2004-03-31 07:35:16 +08:00
|
|
|
|
Test[Index].Parameters = Parameters;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
|
|
|
|
/* Increment test count */
|
|
|
|
|
Index++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Initialize testing framework
|
2004-08-19 14:32:47 +08:00
|
|
|
|
*
|
|
|
|
|
* ProgName: Name of test program.
|
|
|
|
|
* private_usage: Optional routine provided by test program to print the
|
|
|
|
|
* private portion of usage page. Default to NULL which means none is
|
|
|
|
|
* provided.
|
|
|
|
|
* private_parser: Optional routine provided by test program to parse the
|
|
|
|
|
* private options. Default to NULL which means none is provided.
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
* Albert Cheng 2004/08/17
|
|
|
|
|
* Added the ProgName, private_usage and private_parser arguments.
|
2004-01-07 01:53:13 +08:00
|
|
|
|
*/
|
2004-08-19 14:32:47 +08:00
|
|
|
|
void TestInit(const char *ProgName, void (*private_usage)(void), int (*private_parser)(int ac, char *av[]))
|
2004-01-07 01:53:13 +08:00
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* Turn off automatic error reporting since we do it ourselves. Besides,
|
|
|
|
|
* half the functions this test calls are private, so automatic error
|
|
|
|
|
* reporting wouldn't do much good since it's triggered at the API layer.
|
|
|
|
|
*/
|
2010-09-28 03:02:48 +08:00
|
|
|
|
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
2004-08-19 14:32:47 +08:00
|
|
|
|
/*
|
|
|
|
|
* Record the program name and private routines if provided.
|
|
|
|
|
*/
|
|
|
|
|
TestProgName = ProgName;
|
|
|
|
|
if (NULL != private_usage)
|
|
|
|
|
TestPrivateUsage = private_usage;
|
|
|
|
|
if (NULL != private_parser)
|
|
|
|
|
TestPrivateParser = private_parser;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Print test usage.
|
2004-08-19 14:32:47 +08:00
|
|
|
|
* First print the common test options, then the extra options if provided.
|
|
|
|
|
*
|
|
|
|
|
* Modification:
|
|
|
|
|
* 2004/08/18 Albert Cheng. Add TestPrivateUsage feature.
|
2004-01-07 01:53:13 +08:00
|
|
|
|
*/
|
|
|
|
|
void TestUsage(void)
|
|
|
|
|
{
|
2016-07-19 06:36:44 +08:00
|
|
|
|
unsigned i;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
2004-08-19 14:32:47 +08:00
|
|
|
|
print_func("Usage: %s [-v[erbose] (l[ow]|m[edium]|h[igh]|0-9)] %s\n",
|
|
|
|
|
TestProgName, (TestPrivateUsage ? "<extra options>" : ""));
|
2013-03-07 01:26:48 +08:00
|
|
|
|
print_func(" [-[e]x[clude] name]+ \n");
|
|
|
|
|
print_func(" [-o[nly] name]+ \n");
|
2004-01-07 01:53:13 +08:00
|
|
|
|
print_func(" [-b[egin] name] \n");
|
|
|
|
|
print_func(" [-s[ummary]] \n");
|
|
|
|
|
print_func(" [-c[leanoff]] \n");
|
|
|
|
|
print_func(" [-h[elp]] \n");
|
|
|
|
|
print_func("\n\n");
|
|
|
|
|
print_func("verbose controls the amount of information displayed\n");
|
|
|
|
|
print_func("exclude to exclude tests by name\n");
|
|
|
|
|
print_func("only to name tests which should be run\n");
|
|
|
|
|
print_func("begin start at the name of the test givin\n");
|
|
|
|
|
print_func("summary prints a summary of test results at the end\n");
|
|
|
|
|
print_func("cleanoff does not delete *.hdf files after execution of tests\n");
|
|
|
|
|
print_func("help print out this information\n");
|
2004-08-19 14:32:47 +08:00
|
|
|
|
if (TestPrivateUsage){
|
|
|
|
|
print_func("\nExtra options\n");
|
|
|
|
|
TestPrivateUsage();
|
|
|
|
|
}
|
2004-01-07 01:53:13 +08:00
|
|
|
|
print_func("\n\n");
|
|
|
|
|
print_func("This program currently tests the following: \n\n");
|
|
|
|
|
print_func("%16s %s\n", "Name", "Description");
|
|
|
|
|
print_func("%16s %s\n", "----", "-----------");
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < Index; i++)
|
|
|
|
|
print_func("%16s %s\n", Test[i].Name, Test[i].Description);
|
|
|
|
|
|
|
|
|
|
print_func("\n\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Print test info.
|
|
|
|
|
*/
|
|
|
|
|
void TestInfo(const char *ProgName)
|
|
|
|
|
{
|
|
|
|
|
unsigned major, minor, release;
|
|
|
|
|
|
|
|
|
|
H5get_libversion(&major, &minor, &release);
|
|
|
|
|
|
|
|
|
|
print_func("\nFor help use: %s -help\n",ProgName);
|
|
|
|
|
print_func("Linked with hdf5 version %u.%u release %u\n", major, minor, release);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2004-08-14 05:53:26 +08:00
|
|
|
|
* Parse command line information.
|
|
|
|
|
* argc, argv: the usual command line argument count and strings
|
|
|
|
|
*
|
2014-07-23 03:06:18 +08:00
|
|
|
|
* Return: Void
|
|
|
|
|
* exit EXIT_FAILURE if error is encountered.
|
|
|
|
|
*
|
2004-08-14 05:53:26 +08:00
|
|
|
|
* Modification:
|
2004-08-19 14:32:47 +08:00
|
|
|
|
* 2004/08/18 Albert Cheng. Add extra_parse feature.
|
2004-01-07 01:53:13 +08:00
|
|
|
|
*/
|
2004-08-19 14:32:47 +08:00
|
|
|
|
void TestParseCmdLine(int argc, char *argv[])
|
2004-01-07 01:53:13 +08:00
|
|
|
|
{
|
2015-09-17 06:27:49 +08:00
|
|
|
|
hbool_t skipped_all = FALSE;
|
2004-08-24 07:35:17 +08:00
|
|
|
|
int ret_code;
|
|
|
|
|
|
2004-08-14 05:53:26 +08:00
|
|
|
|
while (argv++, --argc > 0){
|
|
|
|
|
if ((HDstrcmp(*argv, "-verbose") == 0) ||
|
|
|
|
|
(HDstrcmp(*argv, "-v") == 0)) {
|
|
|
|
|
if (argc > 0){
|
|
|
|
|
--argc; ++argv;
|
|
|
|
|
ParseTestVerbosity(*argv);
|
|
|
|
|
}else{
|
|
|
|
|
TestUsage();
|
2014-07-23 03:06:18 +08:00
|
|
|
|
exit(EXIT_FAILURE);
|
2004-08-14 05:53:26 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (((HDstrcmp(*argv, "-exclude") == 0) ||
|
|
|
|
|
(HDstrcmp(*argv, "-x") == 0))) {
|
|
|
|
|
if (argc > 0){
|
|
|
|
|
--argc; ++argv;
|
|
|
|
|
SetTest(*argv, SKIPTEST);
|
|
|
|
|
}else{
|
|
|
|
|
TestUsage();
|
2014-07-23 03:06:18 +08:00
|
|
|
|
exit(EXIT_FAILURE);
|
2004-08-14 05:53:26 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (((HDstrcmp(*argv, "-begin") == 0) ||
|
|
|
|
|
(HDstrcmp(*argv, "-b") == 0))) {
|
|
|
|
|
if (argc > 0){
|
|
|
|
|
--argc; ++argv;
|
|
|
|
|
SetTest(*argv, BEGINTEST);
|
|
|
|
|
}else{
|
|
|
|
|
TestUsage();
|
2014-07-23 03:06:18 +08:00
|
|
|
|
exit(EXIT_FAILURE);
|
2004-08-14 05:53:26 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (((HDstrcmp(*argv, "-only") == 0) ||
|
|
|
|
|
(HDstrcmp(*argv, "-o") == 0))) {
|
2015-09-17 06:27:49 +08:00
|
|
|
|
if(argc > 0) {
|
2016-07-19 06:36:44 +08:00
|
|
|
|
unsigned Loop;
|
2015-09-17 06:27:49 +08:00
|
|
|
|
|
2004-08-14 05:53:26 +08:00
|
|
|
|
--argc; ++argv;
|
2015-09-17 06:27:49 +08:00
|
|
|
|
|
2004-08-14 05:53:26 +08:00
|
|
|
|
/* Skip all tests, then activate only one. */
|
2015-09-17 06:27:49 +08:00
|
|
|
|
if(!skipped_all) {
|
|
|
|
|
for(Loop = 0; Loop < Index; Loop++)
|
|
|
|
|
Test[Loop].SkipFlag = 1;
|
|
|
|
|
skipped_all = TRUE;
|
|
|
|
|
} /* end if */
|
2004-08-14 05:53:26 +08:00
|
|
|
|
SetTest(*argv, ONLYTEST);
|
2015-09-17 06:27:49 +08:00
|
|
|
|
} /* end if */
|
|
|
|
|
else {
|
2004-08-14 05:53:26 +08:00
|
|
|
|
TestUsage();
|
2014-07-23 03:06:18 +08:00
|
|
|
|
exit(EXIT_FAILURE);
|
2004-08-14 05:53:26 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if ((HDstrcmp(*argv, "-summary") == 0) || (HDstrcmp(*argv, "-s") == 0))
|
2004-08-19 14:32:47 +08:00
|
|
|
|
Summary = 1;
|
2004-08-14 05:53:26 +08:00
|
|
|
|
else if ((HDstrcmp(*argv, "-help") == 0) || (HDstrcmp(*argv, "-h") == 0)) {
|
2004-01-07 01:53:13 +08:00
|
|
|
|
TestUsage();
|
2014-07-23 03:06:18 +08:00
|
|
|
|
exit(EXIT_SUCCESS);
|
2004-01-07 01:53:13 +08:00
|
|
|
|
}
|
2004-08-14 05:53:26 +08:00
|
|
|
|
else if ((HDstrcmp(*argv, "-cleanoff") == 0) || (HDstrcmp(*argv, "-c") == 0))
|
2006-01-09 13:14:54 +08:00
|
|
|
|
SetTestNoCleanup();
|
2004-08-14 05:53:26 +08:00
|
|
|
|
else {
|
|
|
|
|
/* non-standard option. Break out. */
|
|
|
|
|
break;
|
|
|
|
|
}
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
2004-08-14 05:53:26 +08:00
|
|
|
|
}
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
2004-08-14 05:53:26 +08:00
|
|
|
|
/* Call extra parsing function if provided. */
|
2004-08-19 14:32:47 +08:00
|
|
|
|
if (NULL != TestPrivateParser){
|
2004-08-24 07:35:17 +08:00
|
|
|
|
ret_code=TestPrivateParser(argc+1, argv-1);
|
|
|
|
|
if (ret_code != 0)
|
2014-07-23 03:06:18 +08:00
|
|
|
|
exit(EXIT_FAILURE);
|
2004-08-14 05:53:26 +08:00
|
|
|
|
}
|
2004-01-07 01:53:13 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Perform Tests.
|
|
|
|
|
*/
|
|
|
|
|
void PerformTests(void)
|
|
|
|
|
{
|
2016-07-19 06:36:44 +08:00
|
|
|
|
unsigned Loop;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
|
|
|
|
for (Loop = 0; Loop < Index; Loop++)
|
|
|
|
|
if (Test[Loop].SkipFlag) {
|
2004-08-14 05:53:26 +08:00
|
|
|
|
MESSAGE(2, ("Skipping -- %s (%s) \n", Test[Loop].Description, Test[Loop].Name));
|
2004-01-07 01:53:13 +08:00
|
|
|
|
} else {
|
|
|
|
|
MESSAGE(2, ("Testing -- %s (%s) \n", Test[Loop].Description, Test[Loop].Name));
|
|
|
|
|
MESSAGE(5, ("===============================================\n"));
|
|
|
|
|
Test[Loop].NumErrors = num_errs;
|
2004-04-02 06:51:47 +08:00
|
|
|
|
Test_parameters = Test[Loop].Parameters;
|
2005-09-20 04:32:18 +08:00
|
|
|
|
ALARM_ON;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
Test[Loop].Call();
|
2005-09-20 04:32:18 +08:00
|
|
|
|
ALARM_OFF;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
Test[Loop].NumErrors = num_errs - Test[Loop].NumErrors;
|
|
|
|
|
MESSAGE(5, ("===============================================\n"));
|
|
|
|
|
MESSAGE(5, ("There were %d errors detected.\n\n", (int)Test[Loop].NumErrors));
|
|
|
|
|
}
|
|
|
|
|
|
2004-04-02 06:51:47 +08:00
|
|
|
|
Test_parameters = NULL; /* clear it. */
|
2004-01-07 01:53:13 +08:00
|
|
|
|
MESSAGE(2, ("\n\n"))
|
|
|
|
|
|
|
|
|
|
if (num_errs)
|
|
|
|
|
print_func("!!! %d Error(s) were detected !!!\n\n", (int) num_errs);
|
|
|
|
|
else
|
|
|
|
|
print_func("All tests were successful. \n\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Display test summary.
|
|
|
|
|
*/
|
|
|
|
|
void TestSummary(void)
|
|
|
|
|
{
|
2016-07-19 06:36:44 +08:00
|
|
|
|
unsigned Loop;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
|
|
|
|
print_func("Summary of Test Results:\n");
|
|
|
|
|
print_func("Name of Test Errors Description of Test\n");
|
|
|
|
|
print_func("---------------- ------ --------------------------------------\n");
|
|
|
|
|
|
|
|
|
|
for (Loop = 0; Loop < Index; Loop++) {
|
|
|
|
|
if (Test[Loop].NumErrors == -1)
|
|
|
|
|
print_func("%16s %6s %s\n", Test[Loop].Name, "N/A", Test[Loop].Description);
|
|
|
|
|
else
|
|
|
|
|
print_func("%16s %6d %s\n", Test[Loop].Name, (int)Test[Loop].NumErrors, Test[Loop].Description);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
print_func("\n\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Cleanup files from testing
|
|
|
|
|
*/
|
|
|
|
|
void TestCleanup(void)
|
|
|
|
|
{
|
2016-07-19 06:36:44 +08:00
|
|
|
|
unsigned Loop;
|
2004-01-07 01:53:13 +08:00
|
|
|
|
|
|
|
|
|
MESSAGE(2, ("\nCleaning Up temp files...\n\n"));
|
|
|
|
|
|
|
|
|
|
/* call individual cleanup routines in each source module */
|
|
|
|
|
for (Loop = 0; Loop < Index; Loop++)
|
|
|
|
|
if (!Test[Loop].SkipFlag && Test[Loop].Cleanup!=NULL)
|
|
|
|
|
Test[Loop].Cleanup();
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-19 06:36:44 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Shutdown the test infrastructure
|
|
|
|
|
*/
|
|
|
|
|
void TestShutdown(void)
|
|
|
|
|
{
|
|
|
|
|
if(Test)
|
|
|
|
|
HDfree(Test);
|
|
|
|
|
}
|
|
|
|
|
|
2004-01-10 09:41:13 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Retrieve the verbosity level for the testing framework
|
|
|
|
|
*/
|
2016-06-29 05:53:48 +08:00
|
|
|
|
H5_ATTR_PURE int GetTestVerbosity(void)
|
2004-01-10 09:41:13 +08:00
|
|
|
|
{
|
2010-01-23 05:17:48 +08:00
|
|
|
|
return(TestVerbosity);
|
2004-01-10 09:41:13 +08:00
|
|
|
|
}
|
|
|
|
|
|
2004-01-23 07:05:55 +08:00
|
|
|
|
/*
|
|
|
|
|
* Set the verbosity level for the testing framework.
|
|
|
|
|
* Return previous verbosity level.
|
|
|
|
|
*/
|
2004-01-23 11:33:51 +08:00
|
|
|
|
int SetTestVerbosity(int newval)
|
2004-01-23 07:05:55 +08:00
|
|
|
|
{
|
2004-01-23 11:33:51 +08:00
|
|
|
|
int oldval;
|
2004-01-23 07:05:55 +08:00
|
|
|
|
|
2010-01-23 05:17:48 +08:00
|
|
|
|
oldval = TestVerbosity;
|
|
|
|
|
TestVerbosity = newval;
|
2004-01-23 11:33:51 +08:00
|
|
|
|
return(oldval);
|
2004-01-23 07:05:55 +08:00
|
|
|
|
}
|
|
|
|
|
|
2006-04-07 23:34:40 +08:00
|
|
|
|
/*
|
|
|
|
|
* Retrieve the TestExpress mode for the testing framework
|
2006-06-27 22:45:06 +08:00
|
|
|
|
Values:
|
2006-06-22 06:44:45 +08:00
|
|
|
|
0: Exhaustive run
|
|
|
|
|
Tests should take as long as necessary
|
|
|
|
|
1: Full run. Default if HDF5TestExpress is not defined
|
|
|
|
|
Tests should take no more than 30 minutes
|
|
|
|
|
2: Quick run
|
|
|
|
|
Tests should take no more than 10 minutes
|
|
|
|
|
3: Smoke test. Default if HDF5TestExpress is set to a value other than 0-3
|
|
|
|
|
Tests should take less than 1 minute
|
|
|
|
|
|
|
|
|
|
Design:
|
2006-04-07 23:34:40 +08:00
|
|
|
|
If the environment variable $HDF5TestExpress is defined,
|
2006-06-22 06:44:45 +08:00
|
|
|
|
then test programs should skip some tests so that they
|
|
|
|
|
complete sooner.
|
2006-04-07 23:34:40 +08:00
|
|
|
|
|
|
|
|
|
Terms:
|
2006-06-22 06:44:45 +08:00
|
|
|
|
A "test" is a single executable, even if it contains multiple
|
|
|
|
|
sub-tests.
|
|
|
|
|
The standard system for test times is a Linux machine running in
|
|
|
|
|
NFS space (to catch tests that involve a great deal of disk I/O).
|
2006-06-27 22:45:06 +08:00
|
|
|
|
|
2006-04-07 23:34:40 +08:00
|
|
|
|
Implementation:
|
|
|
|
|
I think this can be easily implemented in the test library (libh5test.a)
|
|
|
|
|
so that all tests can just call it to check the status of $HDF5TestExpress.
|
|
|
|
|
*/
|
|
|
|
|
int GetTestExpress(void)
|
|
|
|
|
{
|
2006-06-22 06:44:45 +08:00
|
|
|
|
char * env_val;
|
|
|
|
|
|
2006-04-07 23:34:40 +08:00
|
|
|
|
/* set it here for now. Should be done in something like h5test_init(). */
|
2006-06-22 06:44:45 +08:00
|
|
|
|
if(TestExpress==-1)
|
|
|
|
|
{
|
|
|
|
|
env_val = getenv("HDF5TestExpress");
|
|
|
|
|
|
|
|
|
|
if(env_val == NULL)
|
|
|
|
|
SetTestExpress(1);
|
|
|
|
|
else if(strcmp(env_val, "0") == 0)
|
|
|
|
|
SetTestExpress(0);
|
|
|
|
|
else if(strcmp(env_val, "1") == 0)
|
|
|
|
|
SetTestExpress(1);
|
|
|
|
|
else if(strcmp(env_val, "2") == 0)
|
|
|
|
|
SetTestExpress(2);
|
|
|
|
|
else
|
|
|
|
|
SetTestExpress(3);
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-07 23:34:40 +08:00
|
|
|
|
return(TestExpress);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Set the TestExpress mode for the testing framework.
|
|
|
|
|
* Return previous TestExpress mode.
|
|
|
|
|
* Values: non-zero means TestExpress mode is on, 0 means off.
|
|
|
|
|
*/
|
|
|
|
|
int SetTestExpress(int newval)
|
|
|
|
|
{
|
|
|
|
|
int oldval;
|
|
|
|
|
|
|
|
|
|
oldval = TestExpress;
|
|
|
|
|
TestExpress = newval;
|
|
|
|
|
return(oldval);
|
|
|
|
|
}
|
|
|
|
|
|
2004-08-19 14:32:47 +08:00
|
|
|
|
/*
|
|
|
|
|
* Retrieve Summary request value.
|
|
|
|
|
* 0 means no summary, 1 means yes.
|
|
|
|
|
*/
|
2016-06-29 05:53:48 +08:00
|
|
|
|
H5_ATTR_PURE int GetTestSummary(void)
|
2004-08-19 14:32:47 +08:00
|
|
|
|
{
|
|
|
|
|
return(Summary);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Retrieve Cleanup request value.
|
|
|
|
|
* 0 means no Cleanup, 1 means yes.
|
|
|
|
|
*/
|
2016-06-29 05:53:48 +08:00
|
|
|
|
H5_ATTR_PURE int GetTestCleanup(void)
|
2004-08-19 14:32:47 +08:00
|
|
|
|
{
|
|
|
|
|
return(CleanUp);
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-09 13:14:54 +08:00
|
|
|
|
/*
|
|
|
|
|
* Set cleanup to no.
|
|
|
|
|
* Return previous cleanup value.
|
|
|
|
|
*/
|
|
|
|
|
int SetTestNoCleanup(void)
|
|
|
|
|
{
|
|
|
|
|
int oldval;
|
|
|
|
|
|
|
|
|
|
oldval = CleanUp;
|
|
|
|
|
CleanUp = 0;
|
|
|
|
|
return(oldval);
|
|
|
|
|
}
|
|
|
|
|
|
2004-01-23 14:29:57 +08:00
|
|
|
|
/*
|
|
|
|
|
* Parse an argument string for verbosity level and set it.
|
|
|
|
|
*/
|
|
|
|
|
void ParseTestVerbosity(char *argv)
|
|
|
|
|
{
|
|
|
|
|
if (*argv == 'l')
|
|
|
|
|
SetTestVerbosity(VERBO_LO);
|
|
|
|
|
else if (*argv == 'm')
|
|
|
|
|
SetTestVerbosity(VERBO_MED);
|
|
|
|
|
else if (*argv == 'h')
|
|
|
|
|
SetTestVerbosity(VERBO_HI);
|
|
|
|
|
else
|
|
|
|
|
SetTestVerbosity(atoi(argv));
|
|
|
|
|
}
|
|
|
|
|
|
2004-01-10 09:41:13 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Retrieve the number of testing errors for the testing framework
|
|
|
|
|
*/
|
2016-06-29 05:53:48 +08:00
|
|
|
|
H5_ATTR_PURE int GetTestNumErrs(void)
|
2004-01-10 09:41:13 +08:00
|
|
|
|
{
|
|
|
|
|
return(num_errs);
|
|
|
|
|
}
|
|
|
|
|
|
2005-03-19 22:11:40 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Increment the number of testing errors
|
|
|
|
|
*/
|
|
|
|
|
void IncTestNumErrs(void)
|
|
|
|
|
{
|
|
|
|
|
num_errs++;
|
|
|
|
|
}
|
|
|
|
|
|
2004-04-02 06:51:47 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Retrieve the current Test Parameters pointer.
|
|
|
|
|
*/
|
2016-06-29 05:53:48 +08:00
|
|
|
|
H5_ATTR_PURE const void *GetTestParameters(void)
|
2004-04-02 06:51:47 +08:00
|
|
|
|
{
|
|
|
|
|
return(Test_parameters);
|
|
|
|
|
}
|
|
|
|
|
|
2004-01-10 09:41:13 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This routine is designed to provide equivalent functionality to 'printf'
|
|
|
|
|
* and also increment the error count for the testing framework.
|
|
|
|
|
*/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
int
|
2004-01-10 09:41:13 +08:00
|
|
|
|
TestErrPrintf(const char *format, ...)
|
|
|
|
|
{
|
|
|
|
|
va_list arglist;
|
|
|
|
|
int ret_value;
|
|
|
|
|
|
|
|
|
|
/* Increment the error count */
|
|
|
|
|
num_errs++;
|
|
|
|
|
|
|
|
|
|
/* Print the requested information */
|
|
|
|
|
va_start(arglist, format);
|
|
|
|
|
ret_value = vprintf(format, arglist);
|
|
|
|
|
va_end(arglist);
|
|
|
|
|
|
|
|
|
|
/* Return the length of the string produced (like printf() does) */
|
|
|
|
|
return ret_value;
|
|
|
|
|
}
|
|
|
|
|
|
2004-04-04 05:35:01 +08:00
|
|
|
|
|
2005-08-14 04:53:35 +08:00
|
|
|
|
/*
|
2004-04-04 05:35:01 +08:00
|
|
|
|
* Set (control) which test will be tested.
|
|
|
|
|
* SKIPTEST: skip this test
|
|
|
|
|
* ONLYTEST: do only this test
|
|
|
|
|
* BEGINETEST: skip all tests before this test
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
void SetTest(const char *testname, int action)
|
|
|
|
|
{
|
2016-07-19 06:36:44 +08:00
|
|
|
|
unsigned Loop;
|
2015-09-17 06:27:49 +08:00
|
|
|
|
|
2004-04-04 05:35:01 +08:00
|
|
|
|
switch (action){
|
|
|
|
|
case SKIPTEST:
|
|
|
|
|
for (Loop = 0; Loop < Index; Loop++)
|
|
|
|
|
if (HDstrcmp(testname, Test[Loop].Name) == 0){
|
|
|
|
|
Test[Loop].SkipFlag = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case BEGINTEST:
|
|
|
|
|
for (Loop = 0; Loop < Index; Loop++) {
|
|
|
|
|
if (HDstrcmp(testname, Test[Loop].Name) != 0)
|
|
|
|
|
Test[Loop].SkipFlag = 1;
|
2004-08-14 05:53:26 +08:00
|
|
|
|
else{
|
|
|
|
|
/* Found it. Set it to run. Done. */
|
|
|
|
|
Test[Loop].SkipFlag = 0;
|
2004-04-04 05:35:01 +08:00
|
|
|
|
break;
|
2004-08-14 05:53:26 +08:00
|
|
|
|
}
|
2004-04-04 05:35:01 +08:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case ONLYTEST:
|
|
|
|
|
for (Loop = 0; Loop < Index; Loop++) {
|
2015-09-17 06:27:49 +08:00
|
|
|
|
if (HDstrcmp(testname, Test[Loop].Name) == 0) {
|
2004-08-14 05:53:26 +08:00
|
|
|
|
/* Found it. Set it to run. Break to skip the rest. */
|
2004-04-04 05:35:01 +08:00
|
|
|
|
Test[Loop].SkipFlag = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
/* error */
|
|
|
|
|
printf("*** ERROR: Unknown action (%d) for SetTest\n", action);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-08-17 05:04:53 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Enable alarm on test execution, configurable by environment variable
|
|
|
|
|
*/
|
|
|
|
|
void TestAlarmOn(void)
|
|
|
|
|
{
|
|
|
|
|
char * env_val = HDgetenv("HDF5_ALARM_SECONDS"); /* Alarm environment */
|
|
|
|
|
unsigned long alarm_sec = H5_ALARM_SEC; /* Number of seconds before alarm goes off */
|
|
|
|
|
|
|
|
|
|
/* Get the alarm value from the environment variable, if set */
|
|
|
|
|
if(env_val != NULL)
|
|
|
|
|
alarm_sec = (unsigned)HDstrtoul(env_val, (char **)NULL, 10);
|
|
|
|
|
|
|
|
|
|
/* Set the number of seconds before alarm goes off */
|
|
|
|
|
HDalarm((unsigned)alarm_sec);
|
|
|
|
|
}
|
|
|
|
|
|