/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Copyright by The HDF Group.                                               *
 * Copyright by the Board of Trustees of the University of Illinois.         *
 * All rights reserved.                                                      *
 *                                                                           *
 * This file is part of HDF.  The full HDF copyright notice, including       *
 * terms governing use, modification, and redistribution, is contained in    *
 * the COPYING file, which can be found at the root of the source code       *
 * distribution tree, or in https://support.hdfgroup.org/ftp/HDF/releases/.  *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/****************************************************************************
 * trank0.c - tests that several APIs behave "correctly" when an SDS has
 * 		rank = 0.
 * Structure of the file:
 *    test_rank0 - test routine, called in hdftest.c
 ****************************************************************************/

#include <string.h>

#include "mfhdf.h"

#include "hdftest.h"

#define FILE_NAME "trank0.hdf" /* data file to test for rank=0 */
#define X_LENGTH  3
#define Y_LENGTH  3
#define RANK      0

/* Test routine for testing the several APIs with SDS having rank = 0. */
extern int
test_rank0()
{
    int32         fid, sds1_id, sds2_id, sds_id;
    int32         dim_sizes[2], array_rank, num_type, attributes;
    int32         start[2], edges[2];
    comp_coder_t  comp_type; /* to retrieve compression type into */
    comp_info     c_info;    /* compression information structure */
    int32         comp_flag; /* compression flag */
    HDF_CHUNK_DEF c_def;     /* Chunking definitions */
    int32         buf[Y_LENGTH][X_LENGTH];
    intn          i, j, status;
    int32         status_32;
    intn          num_errs = 0; /* number of errors so far */

    /* Output message about test being performed */
    TESTING("several APIs with SDS having rank = 0 (trank0.c)");

    /* Create a file */
    fid = SDstart(FILE_NAME, DFACC_CREATE);
    CHECK(fid, FAIL, "test_rank0: SDstart");

    /**** Verify that SDsetcompress fails when dataset has rank 0 ****/

    /* Create an X_LENGTH by Y_LENGTH dataset, called DataSet_1 */
    dim_sizes[0] = X_LENGTH;
    dim_sizes[1] = Y_LENGTH;
    sds1_id      = SDcreate(fid, "DataSet_1", DFNT_INT32, RANK, dim_sizes);
    CHECK(sds1_id, FAIL, "test_rank0: SDcreate");

    /* Attempt to set compress but should fail */
    comp_type            = COMP_CODE_DEFLATE;
    c_info.deflate.level = 6;
    status               = SDsetcompress(sds1_id, comp_type, &c_info);
    VERIFY(status, FAIL, "test_rank0: SDsetcompress");

    /**** Verify that SDsetchunk fails when dataset has rank 0 ****/

    /* Create an X_LENGTH by Y_LENGTH dataset, called DataSet_2 */
    sds2_id = SDcreate(fid, "DataSet_2", DFNT_INT32, RANK, dim_sizes);
    CHECK(sds2_id, FAIL, "test_rank0: SDcreate");

    /* Attempt to set chunk but should fail */
    memset(&c_def, 0, sizeof(HDF_CHUNK_DEF));
    comp_flag = HDF_CHUNK;
    status    = SDsetchunk(sds2_id, c_def, comp_flag);
    VERIFY(status, FAIL, "test_rank0: SDsetchunk");

    /* Close the SDSs */
    status = SDendaccess(sds1_id);
    CHECK(status, FAIL, "test_rank0: SDendaccess");
    status = SDendaccess(sds2_id);
    CHECK(status, FAIL, "test_rank0: SDendaccess");

    /**** Verify that SDwritedata fails when dataset has rank 0 ****/

    /* Initialize buffer and its copy, so later can verify that the buffer
       is not corrupted */
    for (j = 0; j < Y_LENGTH; j++) {
        for (i = 0; i < X_LENGTH; i++) {
            buf[j][i] = i;
        }
    }
    /* Select the first dataset */
    sds_id = SDselect(fid, 0);
    CHECK(sds_id, FAIL, "test_rank0: SDselect");

    /* Define the location and size of the dataset to be written to the file */
    start[0] = 0;
    start[1] = 0;
    edges[0] = Y_LENGTH;
    edges[1] = X_LENGTH;

    /* Write the stored data to the dataset */
    status = SDwritedata(sds_id, start, NULL, edges, (void *)buf);
    VERIFY(status, FAIL, "test_rank0:SDwritedata");

    /* Close the SDS */
    status = SDendaccess(sds_id);
    CHECK(status, FAIL, "test_rank0: SDendaccess");

    /**** Verify that SDreaddata doesn't corrupt user's buffer, when dataset
          has rank 0; at this time, it does (buf[0][0] changed), but EP said
          to just document it for now 2/8/05 - BMR ****/

    /* Select the first dataset */
    sds_id = SDselect(fid, 0);
    CHECK(sds_id, FAIL, "test_rank0: SDselect");

    /* Read the data set */
    start[0] = 0;
    start[1] = 0;
    edges[0] = Y_LENGTH;
    edges[1] = X_LENGTH;
    status   = SDreaddata(sds_id, start, NULL, edges, (void *)buf);
    CHECK(status, FAIL, "test_rank0: SDreaddata");

    /* Close the SDS */
    status = SDendaccess(sds_id);
    CHECK(status, FAIL, "test_rank0: SDendaccess");

    /**** Verify various functions ****/

    /* Select the second dataset */
    sds_id = SDselect(fid, 1);
    CHECK(sds_id, FAIL, "test_rank0: SDselect");

    /* Retrieve information of the data set */
    status = SDgetinfo(sds_id, NULL, &array_rank, dim_sizes, &num_type, &attributes);
    CHECK(status, FAIL, "test_rank0: SDgetinfo");
    VERIFY(array_rank, 0, "test_rank0: SDgetinfo");

    /* Verify that SDisrecord doesn't cause seg. fault */
    status_32 = SDisrecord(sds_id);
    VERIFY(status_32, TRUE, "test_rank0: SDisrecord");

    /* Close the SDSs */
    status = SDendaccess(sds_id);
    CHECK(status, FAIL, "test_rank0: SDendaccess");

    /* Close the SD interface */
    status = SDend(fid);
    CHECK(status, FAIL, "test_rank0: SDend");

    if (num_errs == 0)
        PASSED();
    return num_errs;
}
