mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2024-11-21 03:13:42 +08:00
Code Issues Packages Projects Releases Wiki Activity
965a3aac70
netcdf-c/nc_test4/tst_compounds2.c

267 lines
8.7 KiB
C
Raw Blame History

/* This is part of the netCDF package.
Copyright 2005 University Corporation for Atmospheric Research/Unidata
See COPYRIGHT file for conditions of use.
Test netcdf-4 compound type feature.
$Id: tst_compounds2.c,v 1.15 2010/05/25 13:53:04 ed Exp $
*/
#include <config.h>
#include <stdlib.h>
#include <nc_tests.h>
#define FILE_NAME "tst_compounds2.nc"
int
main(int argc, char **argv)
{
printf("\n*** Testing netcdf-4 user defined type functions, even more.\n");
printf("*** testing compound var containing byte arrays of various size...");
{
#define DIM1_LEN 1
#define ARRAY_LEN (NC_MAX_NAME + 1)
int ncid;
size_t len;
nc_type xtype, type_id;
int dim_sizes[] = {ARRAY_LEN};
int i, j;
struct s1
{
unsigned char x[ARRAY_LEN];
float y;
};
struct s1 data_out[DIM1_LEN], data_in[DIM1_LEN];
char *dummy;
printf("array len=%d... ", ARRAY_LEN);
/* REALLY initialize the data (even the gaps in the structs). This
* is only needed to pass valgrind. */
if (!(dummy = calloc(sizeof(struct s1), DIM1_LEN)))
return NC_ENOMEM;
memcpy((void *)data_out, (void *)dummy, sizeof(struct s1) * DIM1_LEN);
free(dummy);
/* Create some phony data. */
for (i = 0; i < DIM1_LEN; i++)
{
data_out[i].y = 99.99;
for (j = 0; j < ARRAY_LEN; j++)
data_out[i].x[j] = j;
}
/* Create a file with a nested compound type attribute and variable. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
/* Now define the compound type. */
if (nc_def_compound(ncid, sizeof(struct s1), "c", &type_id)) ERR;
if (nc_insert_array_compound(ncid, type_id, "x",
NC_COMPOUND_OFFSET(struct s1, x), NC_UBYTE, 1, dim_sizes)) ERR;
if (nc_insert_compound(ncid, type_id, "y",
NC_COMPOUND_OFFSET(struct s1, y), NC_FLOAT)) ERR;
/* Write it as an attribute. */
if (nc_put_att(ncid, NC_GLOBAL, "a1", type_id, DIM1_LEN, data_out)) ERR;
if (nc_close(ncid)) ERR;
/* Read the att and check values. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_get_att(ncid, NC_GLOBAL, "a1", data_in)) ERR;
for (i=0; i<DIM1_LEN; i++)
{
if (data_in[i].y != data_out[i].y) ERR;
for (j = 0; j < ARRAY_LEN; j++)
if (data_in[i].x[j] != data_out[i].x[j]) ERR_RET;
}
/* Use the inq functions to learn about the compound type. */
if (nc_inq_att(ncid, NC_GLOBAL, "a1", &xtype, &len)) ERR;
if (len != DIM1_LEN) ERR;
/* Finish checking the containing compound type. */
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing compound var on different machines...");
{
#define DIM1_LEN 1
#define NAME1 "x"
#define NAME2 "y"
int ncid;
size_t len;
nc_type xtype, type_id;
char field_name_in[NC_MAX_NAME + 1];
size_t offset_in;
int field_ndims;
nc_type field_typeid;
int i;
struct s1
{
float x;
double y;
};
struct s1 data_out[DIM1_LEN], data_in[DIM1_LEN];
char *dummy;
/* REALLY initialize the data (even the gaps in the structs). This
* is only needed to pass valgrind. */
if (!(dummy = calloc(sizeof(struct s1), DIM1_LEN)))
return NC_ENOMEM;
memcpy((void *)data_out, (void *)dummy, sizeof(struct s1) * DIM1_LEN);
free(dummy);
/* Create some phony data. */
for (i = 0; i < DIM1_LEN; i++)
{
data_out[i].x = 1;
data_out[i].y = -2;
}
/* Create a file with a nested compound type attribute and variable. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
/* Now define the compound type. */
if (nc_def_compound(ncid, sizeof(struct s1), "c", &type_id)) ERR;
if (nc_insert_compound(ncid, type_id, NAME1,
NC_COMPOUND_OFFSET(struct s1, x), NC_FLOAT)) ERR;
if (nc_insert_compound(ncid, type_id, NAME2,
NC_COMPOUND_OFFSET(struct s1, y), NC_DOUBLE)) ERR;
/* Write it as an attribute. */
if (nc_put_att(ncid, NC_GLOBAL, "a1", type_id, DIM1_LEN, data_out)) ERR;
if (nc_close(ncid)) ERR;
/* Read the att and check values. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_get_att(ncid, NC_GLOBAL, "a1", data_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
if (data_in[i].x != data_out[i].x || data_in[i].y != data_out[i].y) ERR;
/* Use the inq functions to learn about the compound type. */
if (nc_inq_att(ncid, NC_GLOBAL, "a1", &xtype, &len)) ERR;
if (len != DIM1_LEN) ERR;
if (nc_inq_compound_field(ncid, xtype, 0, field_name_in,
&offset_in, &field_typeid, &field_ndims, NULL)) ERR;
if (strcmp(field_name_in, NAME1) || field_typeid != NC_FLOAT || field_ndims) ERR;
printf("offset x: %d ", (int)offset_in);
if (nc_inq_compound_field(ncid, xtype, 1, field_name_in,
&offset_in, &field_typeid, &field_ndims, NULL)) ERR;
if (strcmp(field_name_in, NAME2) || field_typeid != NC_DOUBLE || field_ndims) ERR;
printf("offset y: %d NC_COMPOUND_OFFSET(struct s1, y): %d ", (int)offset_in,
(int)NC_COMPOUND_OFFSET(struct s1, y));
/* Finish checking the containing compound type. */
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing compound var containing compound var, on different machines...");
{
#define DIM1_LEN 1
#define S1_NAME_X "x"
#define S1_NAME_Y "y"
#define S2_NAME_S1 "s1"
#define NUM_TYPES 2
#define INNER_TYPE_NAME "c"
#define OUTER_TYPE_NAME "d"
#define ATT_NAME "a1"
int ncid;
size_t len;
nc_type inner_typeid = 0, outer_typeid, s1_typeid, s2_typeid;
char field_name_in[NC_MAX_NAME + 1];
size_t offset_in;
int field_ndims;
nc_type field_typeid;
int i;
struct s1
{
float x;
double y;
};
struct s2
{
struct s1 s1;
};
struct s2 data_out[DIM1_LEN], data_in[DIM1_LEN];
int ntypes, typeids[NUM_TYPES];
size_t size_in, nfields_in;
char name_in[NC_MAX_NAME + 1];
int t;
char *dummy;
/* REALLY initialize the data (even the gaps in the structs). This
* is only needed to pass valgrind. */
if (!(dummy = calloc(sizeof(struct s2), DIM1_LEN)))
return NC_ENOMEM;
memcpy((void *)data_out, (void *)dummy, sizeof(struct s2) * DIM1_LEN);
free(dummy);
/* Create some phony data. */
for (i = 0; i < DIM1_LEN; i++)
{
data_out[i].s1.x = 1;
data_out[i].s1.y = -2;
}
/* Create a file with a nested compound type attribute and variable. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
/* Now define the inner compound type. */
if (nc_def_compound(ncid, sizeof(struct s1), INNER_TYPE_NAME, &s1_typeid)) ERR;
if (nc_insert_compound(ncid, s1_typeid, S1_NAME_X,
NC_COMPOUND_OFFSET(struct s1, x), NC_FLOAT)) ERR;
if (nc_insert_compound(ncid, s1_typeid, S1_NAME_Y,
NC_COMPOUND_OFFSET(struct s1, y), NC_DOUBLE)) ERR;
/* Define the outer compound type. */
if (nc_def_compound(ncid, sizeof(struct s2), OUTER_TYPE_NAME, &s2_typeid)) ERR;
if (nc_insert_compound(ncid, s2_typeid, S2_NAME_S1,
NC_COMPOUND_OFFSET(struct s2, s1), s1_typeid)) ERR;
/* Write it as an attribute. */
if (nc_put_att(ncid, NC_GLOBAL, ATT_NAME, s2_typeid, DIM1_LEN, data_out)) ERR;
if (nc_close(ncid)) ERR;
/* Read the att and check values. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_get_att(ncid, NC_GLOBAL, ATT_NAME, data_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
if (data_in[i].s1.x != data_out[i].s1.x || data_in[i].s1.y != data_out[i].s1.y) ERR;
/* Use the inq functions to learn about the compound type. */
if (nc_inq_typeids(ncid, &ntypes, typeids)) ERR;
if (ntypes != NUM_TYPES) ERR;
for (t = 0; t < NUM_TYPES; t++)
{
if (nc_inq_compound(ncid, typeids[t], name_in, &size_in, &nfields_in)) ERR;
if (!strcmp(name_in, INNER_TYPE_NAME))
inner_typeid = typeids[t];
}
/* What type is the attribute? */
if (nc_inq_att(ncid, NC_GLOBAL, ATT_NAME, &outer_typeid, &len)) ERR;
if (len != DIM1_LEN) ERR;
if (nc_inq_compound_field(ncid, outer_typeid, 0, field_name_in,
&offset_in, &field_typeid, &field_ndims, NULL)) ERR;
if (strcmp(field_name_in, S2_NAME_S1) || field_typeid != inner_typeid || field_ndims) ERR;
if (nc_inq_compound_field(ncid, field_typeid, 1, field_name_in,
&offset_in, &field_typeid, &field_ndims, NULL)) ERR;
if (strcmp(field_name_in, S1_NAME_Y) || field_typeid != NC_DOUBLE || field_ndims) ERR;
/* Finish checking the containing compound type. */
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
Reference in New Issue View Git Blame Copy Permalink