summaryrefslogtreecommitdiffstats
path: root/test/dsets.c
blob: edb951dcce6879f227ff52470ca96fb65249bc49 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
/*
 * Copyright (C) 1997 NCSA
 *                    All rights reserved.
 *
 * Programmer:  Robb Matzke <matzke@llnl.gov>
 *              Tuesday, December  9, 1997
 *
 * Purpose:     Tests the dataset interface (H5D)
 */
#include <assert.h>
#include <hdf5.h>
#include <math.h>
#include <stdio.h>
#include <unistd.h>

#include <H5Eprivate.h>


#ifndef HAVE_FUNCTION
#define __FUNCTION__ ""
#endif
#define AT() printf ("   at %s:%d in %s()...\n",                            \
                     __FILE__, __LINE__, __FUNCTION__);

#define DSET_DEFAULT_NAME       "default"
#define DSET_CHUNKED_NAME       "chunked"
#define DSET_SIMPLE_IO_NAME     "simple_io"
#define DSET_TCONV_NAME         "tconv"

/*-------------------------------------------------------------------------
 * Function:    test_create
 *
 * Purpose:     Attempts to create a dataset.
 *
 * Return:      Success:        SUCCEED
 *
 *              Failure:        FAIL
 *
 * Programmer:  Robb Matzke
 *              Tuesday, December  9, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
test_create(hid_t file)
{
    hid_t                   dataset, space, create_parms;
    size_t                  dims[2];
    herr_t                  status;
    size_t                  csize[2];

    printf("%-70s", "Testing create/open/close");

    /* Create the data space */
    dims[0] = 256;
    dims[1] = 512;
    space = H5Pcreate_simple(2,dims);
    assert(space != FAIL);

    /*
     * Create a dataset using the default dataset creation properties.  We're
     * not sure what they are, so we won't check.
     */
    dataset = H5Dcreate(file, DSET_DEFAULT_NAME, H5T_NATIVE_DOUBLE, space,
                        H5C_DEFAULT);
    if (dataset < 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   Cannot create initial dataset.\n");
        }
        goto error;
    }
    /* Close the dataset */
    if (H5Dclose(dataset) < 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   Cannot close initial dataset.\n");
        }
        goto error;
    }
    /*
     * Try creating a dataset that already exists.  This should fail since a
     * dataset can only be created once.
     */
    dataset = H5Dcreate(file, DSET_DEFAULT_NAME, H5T_NATIVE_DOUBLE, space,
                        H5C_DEFAULT);
    if (dataset >= 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   Library allowed overwrite of existing dataset.\n");
        }
        goto error;
    }
    /*
     * Open the dataset we created above and then close it.  This is how
     * existing datasets are accessed.
     */
    dataset = H5Dopen(file, DSET_DEFAULT_NAME);
    if (dataset < 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   Cannot open dataset `%s'.\n", DSET_DEFAULT_NAME);
        }
        goto error;
    }
    if (H5Dclose(dataset) < 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   Cannot close dataset.\n");
        }
        goto error;
    }
    /*
     * Try opening a non-existent dataset. This should fail since new datasets
     * cannot be created with this function.
     */
    dataset = H5Dopen(file, "does_not_exist");
    if (dataset >= 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   Opened a non-existent dataset.\n");
        }
        goto error;
    }
    /*
     * Create a new dataset that uses chunked storage instead of the default
     * layout.
     */
    create_parms = H5Ccreate(H5C_DATASET_CREATE);
    assert(create_parms >= 0);
    csize[0] = 5;
    csize[1] = 100;
    status = H5Cset_chunk(create_parms, 2, csize);
    assert(status >= 0);

    dataset = H5Dcreate(file, DSET_CHUNKED_NAME, H5T_NATIVE_DOUBLE, space,
                        create_parms);
    if (dataset < 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   Could not create a chunked dataset.\n");
        }
        goto error;
    }
    /*
     * Close the chunked dataset.
     */
    if (H5Dclose(dataset) < 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   Cannot close chunked dataset.\n");
        }
        goto error;
    }
    puts(" PASSED");
    return SUCCEED;

  error:
    return FAIL;
}

/*-------------------------------------------------------------------------
 * Function:    test_simple_io
 *
 * Purpose:     Tests simple I/O.  That is, reading and writing a complete
 *              multi-dimensional array without data type or data space
 *              conversions, without compression, and stored contiguously.
 *
 * Return:      Success:        SUCCEED
 *
 *              Failure:        FAIL
 *
 * Programmer:  Robb Matzke
 *              Wednesday, December 10, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
test_simple_io(hid_t file)
{
    hid_t                   dataset, space;
    herr_t                  status;
    int                     points[100][200], check[100][200];
    int                     i, j, n;
    size_t                  dims[2];

    printf("%-70s", "Testing simple I/O");

    /* Initialize the dataset */
    for (i = n = 0; i < 100; i++) {
        for (j = 0; j < 100; j++) {
            points[i][j] = n++;
        }
    }

    /* Create the data space */
    dims[0] = 100;
    dims[1] = 200;
    space = H5Pcreate_simple(2,dims);
    assert(space != FAIL);

    /* Create the dataset */
    dataset = H5Dcreate(file, DSET_SIMPLE_IO_NAME, H5T_NATIVE_INT, space,
                        H5C_DEFAULT);
    assert(dataset >= 0);

    /* Write the data to the dataset */
    status = H5Dwrite(dataset, H5T_NATIVE_INT, H5P_ALL, H5P_ALL,
                      H5C_DEFAULT, points);
    if (status < 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   H5Dwrite() failed\n");
        }
        goto error;
    }
    /* Read the dataset back */
    status = H5Dread(dataset, H5T_NATIVE_INT, H5P_ALL, H5P_ALL,
                     H5C_DEFAULT, check);
    if (status < 0) {
        puts("*FAILED*");
        if (!isatty(1)) {
            AT();
            printf("   H5Dread() failed\n");
        }
        goto error;
    }
    /* Check that the values read are the same as the values written */
    for (i = 0; i < 100; i++) {
        for (j = 0; j < 200; j++) {
            if (points[i][j] != check[i][j]) {
                puts("*FAILED*");
                if (!isatty(1)) {
                    AT();
                    printf("   Read different values than written.\n");
                    printf("   At index %d,%d\n", i, j);
                }
                goto error;
            }
        }
    }

    H5Dclose(dataset);

    puts(" PASSED");
    return SUCCEED;

  error:
    return FAIL;
}

/*-------------------------------------------------------------------------
 * Function:    test_tconv
 *
 * Purpose:     Test some simple data type conversion stuff.
 *
 * Return:      Success:        SUCCEED
 *
 *              Failure:        FAIL
 *
 * Programmer:  Robb Matzke
 *              Wednesday, January 14, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
test_tconv(hid_t file)
{
    uint8                   out[4 * 1000000];
    uint8                   in[4 * 1000000];
    intn                    i;
    size_t                  dims[1];
    hid_t                   space, dataset, type;
    herr_t                  status;

    printf("%-70s", "Testing data type conversion");

    /* Initialize the dataset */
    for (i = 0; i < 1000000; i++)
        ((int32 *) out)[i] = 0x11223344;

    /* Create the data space */
    dims[0] = 1000000;
    space = H5Pcreate_simple(1,dims);
    assert(space != FAIL);

    /* Create the data set */
    dataset = H5Dcreate(file, DSET_TCONV_NAME, H5T_NATIVE_INT32, space,
                        H5C_DEFAULT);
    assert(dataset >= 0);

    /* Write the data to the dataset */
    status = H5Dwrite(dataset, H5T_NATIVE_INT32, H5P_ALL, H5P_ALL,
                      H5C_DEFAULT, out);
    if (status<0) H5Eprint (H5E_thrdid_g, stdout);
    assert(status >= 0);

    /* Create a new type with the opposite byte order */
    type = H5Tcopy(H5T_NATIVE_INT32);
    switch (H5Tget_order(type)) {
    case H5T_ORDER_BE:
        H5Tset_order(type, H5T_ORDER_LE);
        break;
    case H5T_ORDER_LE:
        H5Tset_order(type, H5T_ORDER_BE);
        break;
    default:
        assert("funny byte order" && 0);
        break;
    }

    /* Read data with byte order conversion */
    status = H5Dread(dataset, type, H5P_ALL, H5P_ALL, H5C_DEFAULT, in);
    assert(status >= 0);

    /* Check */
    for (i = 0; i < 1000000; i++) {
        assert(in[4 * i + 0] == out[4 * i + 3]);
        assert(in[4 * i + 1] == out[4 * i + 2]);
        assert(in[4 * i + 2] == out[4 * i + 1]);
        assert(in[4 * i + 3] == out[4 * i + 0]);
    }

    H5Dclose(dataset);
    H5Tclose(type);

    puts(" PASSED");
    return SUCCEED;
}

/*-------------------------------------------------------------------------
 * Function:    main
 *
 * Purpose:     Tests the dataset interface (H5D)
 *
 * Return:      Success:        exit(0)
 *
 *              Failure:        exit(1)
 *
 * Programmer:  Robb Matzke
 *              Tuesday, December  9, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
int
main(void)
{
    hid_t                   file;
    herr_t                  status;
    intn                    nerrors = 0;

    unlink("dataset.h5");
    file = H5Fcreate("dataset.h5", H5ACC_DEFAULT, H5C_DEFAULT, H5C_DEFAULT);
    assert(file >= 0);

    status = test_create(file);
    nerrors += status < 0 ? 1 : 0;

    status = test_simple_io(file);
    nerrors += status < 0 ? 1 : 0;

    status = test_tconv(file);
    nerrors += status < 0 ? 1 : 0;

    status = H5Fclose(file);

    if (nerrors) {
        printf("***** %d DATASET 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);
    }
    printf("All dataset tests passed.\n");
    exit(0);
}