mirror of
https://github.com/HDFGroup/hdf5.git
synced 2025-01-06 14:56:51 +08:00
4bf629adc9
./INSTALL_MAINT ./README ./RELEASE Partially updated for second alpha, but haven't updated version numbers yet. ./src/H5.c ./src/H5A.c ./src/H5AC.c ./src/H5B.c ./src/H5D.c ./src/H5F.c ./src/H5Fcore.c ./src/H5Ffamily.c ./src/H5Fistore.c ./src/H5Fmpio.c ./src/H5Fsec2.c ./src/H5Fsplit.c ./src/H5Fstdio.c ./src/H5G.c ./src/H5Gnode.c ./src/H5HG.c ./src/H5HL.c ./src/H5I.c ./src/H5MM.c ./src/H5MMprivate.h ./src/H5O.c ./src/H5Oattr.c ./src/H5Ocomp.c ./src/H5Ocont.c ./src/H5Odtype.c ./src/H5Oefl.c ./src/H5Olayout.c ./src/H5Oname.c ./src/H5Osdspace.c ./src/H5Oshared.c ./src/H5Ostab.c ./src/H5P.c ./src/H5S.c ./src/H5T.c ./src/H5Tconv.c ./src/H5detect.c ./test/hyperslab.c ./test/istore.c Changed memory allocation functions so they fail instead of dumping core. The `x' was removed from the name to remind us of that: H5MM_xmalloc() -> H5MM_malloc(), etc. H5MM_calloc() takes one argument like H5MM_malloc() instead of two like calloc() because we almost always called it with `1' for one of the arguments anyway. The only difference between the two functions is that H5MM_calloc() returns memory which is initialized to zero. ./src/H5Gent.c ./src/H5Gprivate.h Removed H5G_ent_calloc() since it wasn't used. ./src/H5Fistore.c Fixed a bug found by Albert. Thanks, Albert! This fix combined with the changes to memory allocation prevent the library from failing an assertion if the application uses an unreasonable size for chunks (like Alberts 10000x10000x4). ./src/H5MF.c ./src/H5MFprivate.h Changed H5MF_free() to H5MF_xfree() since calling it with an undefined address is allowed.
704 lines
17 KiB
C
704 lines
17 KiB
C
/*
|
||
* Copyright (C) 1997 NCSA
|
||
* All rights reserved.
|
||
*
|
||
* Programmer: Robb Matzke <matzke@llnl.gov>
|
||
* Wednesday, October 15, 1997
|
||
*
|
||
* Purpose: Tests various aspects of indexed raw data storage.
|
||
*/
|
||
#include <H5private.h>
|
||
#include <H5Iprivate.h>
|
||
#include <H5Pprivate.h>
|
||
#include <H5Fprivate.h>
|
||
#include <H5Gprivate.h>
|
||
#include <H5MMprivate.h>
|
||
#include <H5Oprivate.h>
|
||
#include <H5Vprivate.h>
|
||
|
||
#if 1
|
||
# define FILETYPE H5F_LOW_DFLT
|
||
# define FILENAME "istore.h5"
|
||
#elif 0
|
||
# define FILETYPE H5F_LOW_FAM
|
||
# define FILENAME "istore-%05d.h5"
|
||
# define TEST_FAMILY 1
|
||
#else
|
||
# define FILETYPE H5F_LOW_SPLIT
|
||
# define FILENAME "istore-split"
|
||
#endif
|
||
|
||
#define TEST_SMALL 0x0001
|
||
#define TEST_MEDIUM 0x0002
|
||
#define TEST_LARGE 0x0004
|
||
|
||
#ifndef HAVE_FUNCTION
|
||
#undef __FUNCTION__
|
||
#define __FUNCTION__ ""
|
||
#endif
|
||
#define AT() printf (" at %s:%d in %s()...\n", \
|
||
__FILE__, __LINE__, __FUNCTION__);
|
||
|
||
hsize_t align_g[3] = {50, 50, 50};
|
||
hssize_t zero[H5O_LAYOUT_NDIMS];
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: print_array
|
||
*
|
||
* Purpose: Prints the values in an array
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Friday, October 10, 1997
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
print_array(uint8 *array, size_t nx, size_t ny, size_t nz)
|
||
{
|
||
size_t i, j, k;
|
||
|
||
for (i = 0; i < nx; i++) {
|
||
if (nz > 1) {
|
||
printf("i=%d:\n", i);
|
||
} else {
|
||
printf("%03d:", i);
|
||
}
|
||
|
||
for (j = 0; j < ny; j++) {
|
||
if (nz > 1)
|
||
printf("%03d:", j);
|
||
for (k = 0; k < nz; k++) {
|
||
printf(" %3d", *array++);
|
||
}
|
||
if (nz > 1)
|
||
printf("\n");
|
||
}
|
||
printf("\n");
|
||
}
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: new_object
|
||
*
|
||
* Purpose: Creates a new object that refers to a indexed storage of raw
|
||
* data. No raw data is stored.
|
||
*
|
||
* Return: Success: Handle to a new open object.
|
||
*
|
||
* Failure: NULL, error message printed.
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, October 15, 1997
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
new_object(H5F_t *f, const char *name, intn ndims, H5G_entry_t *ent/*out*/)
|
||
{
|
||
H5O_layout_t layout;
|
||
intn i;
|
||
|
||
/* Create the object header */
|
||
if (H5O_create(f, 64, ent)) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" H5O_create() = NULL\n");
|
||
}
|
||
return -1;
|
||
}
|
||
/* create chunked storage */
|
||
layout.type = H5D_CHUNKED;
|
||
layout.ndims = ndims;
|
||
for (i = 0; i < ndims; i++) {
|
||
if (i < (int)NELMTS(align_g)) {
|
||
layout.dim[i] = align_g[i];
|
||
} else {
|
||
layout.dim[i] = 2;
|
||
}
|
||
}
|
||
H5F_arr_create(f, &layout/*in,out*/);
|
||
if (H5O_modify(ent, H5O_LAYOUT, H5O_NEW_MESG, 0, &layout) < 0) {
|
||
printf("*FAILED*\n");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" H5O_modify istore message failure\n");
|
||
}
|
||
return -1;
|
||
}
|
||
/* Give the object header a name */
|
||
if (H5G_insert(H5G_getcwg(f), name, ent) < 0) {
|
||
printf("*FAILED*\n");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" H5G_insert(f, name=\"%s\", ent) failed\n", name);
|
||
}
|
||
return -1;
|
||
}
|
||
/* Close the header */
|
||
H5O_close(ent);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_create
|
||
*
|
||
* Purpose: Creates a named object that refers to indexed storage of raw
|
||
* data. No raw data is stored.
|
||
*
|
||
* Return: Success: SUCCEED
|
||
*
|
||
* Failure: FAIL
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, October 15, 1997
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_create(H5F_t *f, const char *prefix)
|
||
{
|
||
H5G_entry_t handle;
|
||
intn i;
|
||
char name[256];
|
||
|
||
printf("%-70s", "Testing istore create");
|
||
|
||
for (i = 1; i <= H5O_LAYOUT_NDIMS; i++) {
|
||
sprintf(name, "%s_%02d", prefix, i);
|
||
if (new_object(f, name, i, &handle) < 0)
|
||
return FAIL;
|
||
}
|
||
|
||
puts(" PASSED");
|
||
return SUCCEED;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_extend
|
||
*
|
||
* Purpose: Creates an empty object and then writes to it in such a way
|
||
* as to always extend the object's domain without creating
|
||
* holes and without causing the object to become concave.
|
||
*
|
||
* Return: Success: SUCCEED
|
||
*
|
||
* Failure: FAIL
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, October 15, 1997
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_extend(H5F_t *f, const char *prefix,
|
||
size_t nx, size_t ny, size_t nz)
|
||
{
|
||
H5G_entry_t handle;
|
||
hsize_t i, j, k, ctr;
|
||
int ndims;
|
||
uint8 *buf = NULL, *check = NULL, *whole = NULL;
|
||
char dims[64], s[256], name[256];
|
||
hssize_t offset[3];
|
||
hssize_t max_corner[3];
|
||
hsize_t size[3];
|
||
hsize_t whole_size[3];
|
||
hsize_t nelmts;
|
||
H5O_layout_t layout;
|
||
|
||
if (!nz) {
|
||
if (!ny) {
|
||
ndims = 1;
|
||
ny = nz = 1;
|
||
sprintf(dims, "%lu", (unsigned long) nx);
|
||
} else {
|
||
ndims = 2;
|
||
nz = 1;
|
||
sprintf(dims, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
|
||
}
|
||
} else {
|
||
ndims = 3;
|
||
sprintf(dims, "%lux%lux%lu",
|
||
(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
|
||
}
|
||
|
||
sprintf(s, "Testing istore extend: %s", dims);
|
||
printf("%-70s", s);
|
||
buf = H5MM_malloc(nx * ny * nz);
|
||
check = H5MM_malloc(nx * ny * nz);
|
||
whole = H5MM_calloc(nx*ny*nz);
|
||
|
||
/* Build the new empty object */
|
||
sprintf(name, "%s_%s", prefix, dims);
|
||
if (new_object(f, name, ndims, &handle) < 0) {
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Cannot create %d-d object `%s'\n", ndims, name);
|
||
}
|
||
goto error;
|
||
}
|
||
if (NULL == H5O_read(&handle, H5O_LAYOUT, 0, &layout)) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Unable to read istore message\n");
|
||
}
|
||
goto error;
|
||
}
|
||
if (ndims != layout.ndims) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Header read error: istore.ndims != %d\n", ndims);
|
||
}
|
||
goto error;
|
||
}
|
||
whole_size[0] = nx;
|
||
whole_size[1] = ny;
|
||
whole_size[2] = nz;
|
||
max_corner[0] = 0;
|
||
max_corner[1] = 0;
|
||
max_corner[2] = 0;
|
||
|
||
for (ctr = 0;
|
||
H5V_vector_lt_s(ndims, max_corner, (hssize_t*)whole_size);
|
||
ctr++) {
|
||
|
||
/* Size and location */
|
||
if (0 == ctr) {
|
||
offset[0] = offset[1] = offset[2] = 0;
|
||
size[0] = size[1] = size[2] = 1;
|
||
nelmts = 1;
|
||
} else {
|
||
for (i=0, nelmts=1; i<(size_t)ndims; i++) {
|
||
if (ctr % ndims == i) {
|
||
offset[i] = max_corner[i];
|
||
size[i] = MIN(1, whole_size[i] - offset[i]);
|
||
} else {
|
||
offset[i] = 0;
|
||
size[i] = max_corner[i];
|
||
}
|
||
nelmts *= size[i];
|
||
}
|
||
}
|
||
|
||
#if 0
|
||
if (0 == ctr)
|
||
printf("\n");
|
||
printf(" Insert: ctr=%d, corner=(%d", ctr, offset[0]);
|
||
if (ndims > 1)
|
||
printf(",%d", offset[1]);
|
||
if (ndims > 2)
|
||
printf(",%d", offset[2]);
|
||
printf("), size=(%d", size[0]);
|
||
if (ndims > 1)
|
||
printf(",%d", size[1]);
|
||
if (ndims > 2)
|
||
printf(",%d", size[2]);
|
||
printf("), %d element%s", nelmts, 1 == nelmts ? "" : "s");
|
||
if (0 == nelmts)
|
||
printf(" *SKIPPED*");
|
||
printf("\n");
|
||
#endif
|
||
|
||
/* Fill the source array */
|
||
if (0 == nelmts) continue;
|
||
memset(buf, (signed)(128+ctr), (size_t)nelmts);
|
||
|
||
/* Write to disk */
|
||
if (H5F_arr_write(f, &layout, NULL, NULL, size, size, zero, offset,
|
||
H5D_XFER_DFLT, buf)<0) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Write failed: ctr=%lu\n", (unsigned long)ctr);
|
||
}
|
||
goto error;
|
||
}
|
||
/* Read from disk */
|
||
memset(check, 0xff, (size_t)nelmts);
|
||
if (H5F_arr_read(f, &layout, NULL, NULL, size, size, zero, offset,
|
||
H5D_XFER_DFLT, check)<0) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Read failed: ctr=%lu\n", (unsigned long)ctr);
|
||
}
|
||
goto error;
|
||
}
|
||
if (memcmp(buf, check, (size_t)nelmts)) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Read check failed: ctr=%lu\n", (unsigned long)ctr);
|
||
printf(" Wrote:\n");
|
||
print_array(buf, (size_t)size[0], (size_t)size[1],
|
||
(size_t)size[2]);
|
||
printf(" Read:\n");
|
||
print_array(check, (size_t)size[0], (size_t)size[1],
|
||
(size_t)size[2]);
|
||
}
|
||
goto error;
|
||
}
|
||
/* Write to `whole' buffer for later checking */
|
||
H5V_hyper_copy(ndims, size,
|
||
whole_size, offset, whole, /*dst */
|
||
size, H5V_ZERO, buf); /*src */
|
||
|
||
/* Update max corner */
|
||
for (i=0; i<(size_t)ndims; i++) {
|
||
max_corner[i] = MAX(max_corner[i], offset[i]+(hssize_t)size[i]);
|
||
}
|
||
}
|
||
|
||
/* Now read the entire array back out and check it */
|
||
memset(buf, 0xff, nx * ny * nz);
|
||
if (H5F_arr_read(f, &layout, NULL, NULL, whole_size, whole_size, zero,
|
||
zero, H5D_XFER_DFLT, buf)<0) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Read failed for whole array\n");
|
||
}
|
||
goto error;
|
||
}
|
||
for (i = 0; i < nx; i++) {
|
||
for (j = 0; j < ny; j++) {
|
||
for (k = 0; k < nz; k++) {
|
||
if (whole[i * ny * nz + j * nz + k] != buf[i * ny * nz + j * nz + k]) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Check failed at i=%lu", (unsigned long)i);
|
||
if (ndims > 1) {
|
||
printf(", j=%lu", (unsigned long)j);
|
||
}
|
||
if (ndims > 2) {
|
||
printf(", k=%lu", (unsigned long)k);
|
||
}
|
||
printf("\n Check array is:\n");
|
||
print_array(whole, nx, ny, nz);
|
||
printf(" Value read is:\n");
|
||
print_array(buf, nx, ny, nz);
|
||
}
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
puts(" PASSED");
|
||
H5MM_xfree(buf);
|
||
H5MM_xfree(check);
|
||
H5MM_xfree(whole);
|
||
return SUCCEED;
|
||
|
||
error:
|
||
H5MM_xfree(buf);
|
||
H5MM_xfree(check);
|
||
H5MM_xfree(whole);
|
||
return FAIL;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_sparse
|
||
*
|
||
* Purpose: Creates a sparse matrix consisting of NBLOCKS randomly placed
|
||
* blocks each of size NX,NY,NZ.
|
||
*
|
||
* Return: Success: SUCCEED
|
||
*
|
||
* Failure: FAIL
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, October 22, 1997
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_sparse(H5F_t *f, const char *prefix, size_t nblocks,
|
||
size_t nx, size_t ny, size_t nz)
|
||
{
|
||
intn ndims;
|
||
hsize_t ctr;
|
||
char dims[64], s[256], name[256];
|
||
hssize_t offset[3];
|
||
hsize_t size[3], total = 0;
|
||
H5G_entry_t handle;
|
||
H5O_layout_t layout;
|
||
uint8 *buf = NULL;
|
||
|
||
if (!nz) {
|
||
if (!ny) {
|
||
ndims = 1;
|
||
ny = nz = 1;
|
||
sprintf(dims, "%lu", (unsigned long) nx);
|
||
} else {
|
||
ndims = 2;
|
||
nz = 1;
|
||
sprintf(dims, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
|
||
}
|
||
} else {
|
||
ndims = 3;
|
||
sprintf(dims, "%lux%lux%lu",
|
||
(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
|
||
}
|
||
|
||
sprintf(s, "Testing istore sparse: %s", dims);
|
||
printf("%-70s", s);
|
||
buf = H5MM_malloc(nx * ny * nz);
|
||
|
||
/* Build the new empty object */
|
||
sprintf(name, "%s_%s", prefix, dims);
|
||
if (new_object(f, name, ndims, &handle) < 0) {
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Cannot create %d-d object `%s'\n", ndims, name);
|
||
}
|
||
goto error;
|
||
}
|
||
if (NULL == H5O_read(&handle, H5O_LAYOUT, 0, &layout)) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Unable to read istore message\n");
|
||
}
|
||
goto error;
|
||
}
|
||
for (ctr=0; ctr<nblocks; ctr++) {
|
||
offset[0] = rand() % 1000000;
|
||
offset[1] = rand() % 1000000;
|
||
offset[2] = rand() % 1000000;
|
||
size[0] = nx;
|
||
size[1] = ny;
|
||
size[2] = nz;
|
||
memset(buf, (signed)(128+ctr), nx * ny * nz);
|
||
|
||
/* write to disk */
|
||
if (H5F_arr_write(f, &layout, NULL, NULL, size, size, zero, offset,
|
||
H5D_XFER_DFLT, buf)<0) {
|
||
puts("*FAILED*");
|
||
if (!isatty(1)) {
|
||
AT();
|
||
printf(" Write failed: ctr=%lu\n", (unsigned long)ctr);
|
||
printf(" offset=(%lu", (unsigned long) (offset[0]));
|
||
if (ndims > 1)
|
||
printf(",%lu", (unsigned long) (offset[1]));
|
||
if (ndims > 2)
|
||
printf(",%lu", (unsigned long) (offset[2]));
|
||
printf("), size=(%lu", (unsigned long) (size[0]));
|
||
if (ndims > 1)
|
||
printf(",%lu", (unsigned long) (size[1]));
|
||
if (ndims > 2)
|
||
printf(",%lu", (unsigned long) (size[2]));
|
||
printf(")\n");
|
||
}
|
||
goto error;
|
||
}
|
||
total += nx * ny * nz;
|
||
#if 0
|
||
printf("ctr: ctr=%d, total=%lu\n", ctr, (unsigned long) total);
|
||
#endif
|
||
|
||
/* We don't test reading yet.... */
|
||
}
|
||
|
||
puts(" PASSED");
|
||
H5MM_xfree(buf);
|
||
return SUCCEED;
|
||
|
||
error:
|
||
H5MM_xfree(buf);
|
||
return FAIL;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: cleanup
|
||
*
|
||
* Purpose: Cleanup temporary test files
|
||
*
|
||
* Return: none
|
||
*
|
||
* Programmer: Albert Cheng
|
||
* May 28, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
cleanup(void)
|
||
{
|
||
if (!getenv ("HDF5_NOCLEANUP")) {
|
||
remove(FILENAME);
|
||
}
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: main
|
||
*
|
||
* Purpose: Tests indexed storage stuff.
|
||
*
|
||
* Return: Success: exit(0)
|
||
*
|
||
* Failure: exit(non-zero)
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, October 15, 1997
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int
|
||
main(int argc, char *argv[])
|
||
{
|
||
H5F_t *f;
|
||
herr_t status;
|
||
int nerrors = 0;
|
||
uintn size_of_test;
|
||
hid_t template_id;
|
||
H5F_create_t *creation_template = NULL;
|
||
H5G_t *dir = NULL;
|
||
|
||
setbuf(stdout, NULL);
|
||
|
||
/* Parse arguments or assume `small' */
|
||
if (1 == argc) {
|
||
size_of_test = TEST_SMALL;
|
||
} else {
|
||
intn i;
|
||
for (i = 1, size_of_test = 0; i < argc; i++) {
|
||
if (!strcmp(argv[i], "small")) {
|
||
size_of_test |= TEST_SMALL;
|
||
} else if (!strcmp(argv[i], "medium")) {
|
||
size_of_test |= TEST_MEDIUM;
|
||
} else if (!strcmp(argv[i], "large")) {
|
||
size_of_test |= TEST_LARGE;
|
||
} else {
|
||
printf("unrecognized argument: %s\n", argv[i]);
|
||
#if 0
|
||
exit(1);
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
printf("Test sizes: ");
|
||
if (size_of_test & TEST_SMALL)
|
||
printf(" SMALL");
|
||
if (size_of_test & TEST_MEDIUM)
|
||
printf(" MEDIUM");
|
||
if (size_of_test & TEST_LARGE)
|
||
printf(" LARGE");
|
||
printf("\n");
|
||
|
||
/*
|
||
* Use larger file addresses...
|
||
*/
|
||
template_id = H5Pcreate(H5P_FILE_CREATE);
|
||
H5Pset_sizes(template_id, 8, 0);
|
||
creation_template = H5I_object(template_id);
|
||
|
||
/* Create the test file */
|
||
if (NULL == (f = H5F_open(FILENAME,
|
||
(H5F_ACC_CREAT | H5F_ACC_RDWR | H5F_ACC_TRUNC |
|
||
H5F_ACC_DEBUG),
|
||
creation_template, NULL))) {
|
||
printf("Cannot create file %s; test aborted\n", FILENAME);
|
||
exit(1);
|
||
}
|
||
#ifdef TEST_FAMILY
|
||
{
|
||
/*
|
||
* For testing file families, fool the library into thinking it already
|
||
* allocated a whole bunch of data.
|
||
*/
|
||
haddr_t addr;
|
||
addr.offset = 8 * ((uint64) 1 << 30); /*8 GB */
|
||
H5F_low_seteof(f->shared->lf, &addr);
|
||
}
|
||
#endif
|
||
|
||
/*
|
||
* By creating a group we cause the library to emit it's debugging
|
||
* diagnostic messages before we begin testing...
|
||
*/
|
||
dir = H5G_create(H5G_getcwg(f), "flushing_diagnostics", 0);
|
||
H5G_close(dir);
|
||
dir = NULL;
|
||
|
||
/*
|
||
* Creation test: Creates empty objects with various raw data sizes
|
||
* and alignments.
|
||
*/
|
||
status = test_create(f, "create");
|
||
nerrors += status < 0 ? 1 : 0;
|
||
|
||
if (size_of_test & TEST_SMALL) {
|
||
status = test_extend(f, "extend", 10, 0, 0);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
status = test_extend(f, "extend", 10, 10, 0);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
status = test_extend(f, "extend", 10, 10, 10);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
}
|
||
if (size_of_test & TEST_MEDIUM) {
|
||
status = test_extend(f, "extend", 10000, 0, 0);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
status = test_extend(f, "extend", 2500, 10, 0);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
status = test_extend(f, "extend", 10, 400, 10);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
}
|
||
if (size_of_test & TEST_SMALL) {
|
||
status = test_sparse(f, "sparse", 100, 5, 0, 0);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
status = test_sparse(f, "sparse", 100, 3, 4, 0);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
status = test_sparse(f, "sparse", 100, 2, 3, 4);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
}
|
||
if (size_of_test & TEST_MEDIUM) {
|
||
status = test_sparse(f, "sparse", 1000, 30, 0, 0);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
status = test_sparse(f, "sparse", 2000, 7, 3, 0);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
status = test_sparse(f, "sparse", 2000, 4, 2, 3);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
}
|
||
if (size_of_test & TEST_LARGE) {
|
||
status = test_sparse(f, "sparse", 800, 50, 50, 50);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
}
|
||
/* Close the test file and exit */
|
||
H5F_close(f);
|
||
if (nerrors) {
|
||
printf("***** %d I-STORE TEST%s FAILED! *****\n",
|
||
nerrors, 1 == nerrors ? "" : "S");
|
||
if (isatty(1)) {
|
||
printf("(Redirect output to a pager or a file to see "
|
||
"debug output)\n");
|
||
}
|
||
exit(1);
|
||
}
|
||
H5Pclose (template_id);
|
||
printf("All i-store tests passed.\n");
|
||
cleanup();
|
||
return 0;
|
||
}
|