END_TEST
START_TEST(test_unstruct_mesh_count)
{
const char test_file[] = FILENAME;
hid_t fid;
herr_t status;
int seed = 0xABCD0123;
int num_meshes = generate_random_bound_int(1,10,&seed);
int count;
create_random_meshes(test_file,num_meshes);
status = output_file_open_rdonly(test_file,&fid);
fail_unless ( status == DANU_SUCCESS,
"Failed to open output file");
if ( status == DANU_SUCCESS ) {
status = mesh_count(fid,&count);
fail_unless(status == DANU_SUCCESS,
"Failed to count the number of meshes");
fail_unless(count == num_meshes,
"Number of meshes created does not match number count");
}
output_file_close(&fid);
danu_file_delete(test_file);
}
void create_random_meshes(const char *filename,int num_meshes)
{
hid_t fid,mid;
herr_t status = output_file_create(filename,&fid);
char mesh_name[64];
telem_t elem;
int seed = 0x123456;
int m;
if ( status != DANU_SUCCESS ) {
printf("FAILED TO CREATE DUMMY TEST FILE\n");
fail_exit_now();
}
for(m=1; m <= num_meshes; m++) {
elem = generate_random_bound_int(LINE_ELEM,HEX_ELEM,&seed);
sprintf(mesh_name,"Mesh %02d",m);
status = mesh_create(fid,mesh_name,UNSTRUCTURED_MESH,elem,&mid);
if ( status != DANU_SUCCESS ) {
printf("FAILED TO CREATE DUMMY MESH\n");
fail_exit_now();
}
danu_group_close(mid);
}
output_file_close(&fid);
}
END_TEST
START_TEST (test_unstruct_mesh_open)
{
const char test_file[] = FILENAME;
hid_t fid, mid;
herr_t status;
int seed = 0xABCD0123;
int num_meshes = generate_random_bound_int(1,10,&seed);
int i,m;
char mesh_name[64];
create_random_meshes(test_file,num_meshes);
status = output_file_open_rdonly(test_file,&fid);
fail_unless ( status == DANU_SUCCESS,
"Failed to open output file");
for(m=1;m<=num_meshes;m++) {
sprintf(mesh_name,"Mesh %02d",m);
mid = mesh_open(fid,mesh_name);
fail_unless(H5_ISA_VALID_ID(mid),
"Failed to open existing mesh");
}
output_file_close(&fid);
danu_file_delete(test_file);
}
END_TEST
START_TEST(test_unstruct_mesh_add)
{
const char test_file[] = FILENAME;
hid_t fid,mid;
herr_t status;
int d, m, e;
char mesh_name[32] = "Test Unstructured";
status = output_file_create(test_file,&fid);
fail_unless(status == DANU_SUCCESS,
"Faile to create output file");
/* These should fail */
d = 1;
for( e=3; e<= HEX_ELEM_ORDER ; e++) {
status = mesh_add_unstructured(fid,mesh_name,e,d,&mid);
fail_unless(status == DANU_FAILURE,
"Failed to return bad status with garbage input");
}
/* These should pass */
d = 1;
sprintf(mesh_name, "Test %dD",d);
status = mesh_add_unstructured(fid,mesh_name,LINE_ELEM_ORDER,d,&mid);
fail_unless( status == DANU_SUCCESS,
"Failed to add 1D mesh");
d = 2;
sprintf(mesh_name, "Quad Test %dD",d);
status = mesh_add_unstructured(fid,mesh_name,QUAD_ELEM_ORDER,d,&mid);
fail_unless( status == DANU_SUCCESS,
"Failed to add 2D quad mesh");
sprintf(mesh_name, "TRI Test %dD",d);
status = mesh_add_unstructured(fid,mesh_name,TRI_ELEM_ORDER,d,&mid);
fail_unless( status == DANU_SUCCESS,
"Failed to add 2D tri mesh");
d = 3;
sprintf(mesh_name, "TET Test %dD",d);
status = mesh_add_unstructured(fid,mesh_name,TET_ELEM_ORDER,d,&mid);
fail_unless( status == DANU_SUCCESS,
"Failed to add 3D tet mesh");
sprintf(mesh_name, "HEX Test %dD",d);
status = mesh_add_unstructured(fid,mesh_name,HEX_ELEM_ORDER,d,&mid);
fail_unless( status == DANU_SUCCESS,
"Failed to add 3d HEX mesh");
output_file_close(&fid);
danu_file_delete(test_file);
}
static struct backed_block *move_chunks_up_to_len(struct sparse_file *from,
struct sparse_file *to, unsigned int len)
{
int64_t count = 0;
struct output_file *out_counter;
struct backed_block *last_bb = NULL;
struct backed_block *bb;
struct backed_block *start;
int64_t file_len = 0;
/*
* overhead is sparse file header, initial skip chunk, split chunk, end
* skip chunk, and crc chunk.
*/
int overhead = sizeof(sparse_header_t) + 4 * sizeof(chunk_header_t) +
sizeof(uint32_t);
len -= overhead;
start = backed_block_iter_new(from->backed_block_list);
out_counter = output_file_open_callback(out_counter_write, &count,
to->block_size, to->len, false, true, 0, false);
if (!out_counter) {
return NULL;
}
for (bb = start; bb; bb = backed_block_iter_next(bb)) {
count = 0;
/* will call out_counter_write to update count */
sparse_file_write_block(out_counter, bb);
if (file_len + count > len) {
/*
* If the remaining available size is more than 1/8th of the
* requested size, split the chunk. Results in sparse files that
* are at least 7/8ths of the requested size
*/
if (!last_bb || (len - file_len > (len / 8))) {
backed_block_split(from->backed_block_list, bb, len - file_len);
last_bb = bb;
}
goto out;
}
file_len += count;
last_bb = bb;
}
out:
backed_block_list_move(from->backed_block_list,
to->backed_block_list, start, last_bb);
output_file_close(out_counter);
return bb;
}
END_TEST
START_TEST(test_nsdata_count)
{
hid_t fid, sid;
herr_t err;
int iseed = 0xaa44;
char data_name[32];
int cnt;
int gen_cnt, idx;
int data;
int size;
generate_output_file(&fid,&sid);
fail_unless(H5_ISA_VALID_ID(sid) && H5_ISA_VALID_ID(fid),
"failed to generate test file");
printf("line=%d sid=0x%lx\n", __LINE__,sid);
err = data_count(sid,&cnt);
fail_unless(H5_RETURN_OK(err),
"Failed to return success status");
fail_unless(cnt == 0,
"Failed to return correct count (0)");
printf("line=%d sid=0x%lx\n", __LINE__,sid);
data = generate_random_int(&iseed);
size = 1;
//gen_cnt = generate_random_bound_int(10,1024,&iseed);
gen_cnt=1;
for(idx=0; idx < gen_cnt; idx++) {
sprintf(data_name, "Data Mu %04d",idx);
data_write_int(sid,data_name,1,&size,&data);
}
printf("line=%d sid=0x%lx\n", __LINE__,sid);
err = data_count(sid,&cnt);
fail_unless(H5_RETURN_OK(err),
"Failed to return success status");
fail_unless(cnt == gen_cnt,
"Failed to return correct count (<0)");
printf("line=%d sid=0x%lx\n", __LINE__,sid);
danu_group_close(sid);
output_file_close(&fid);
//file_delete();
}
END_TEST
START_TEST (test_nsdata_read_int)
{
hid_t fid, sid;
char data_name[] = "Test Non-Series INT";
int iseed = 2090;
herr_t err;
int dim = generate_random_bound_int(1,3,&iseed);
int *dimensions;
int *data, *read_data;
int data_size,idx;
generate_output_file(&fid,&sid);
dimensions = DANU_MALLOC(int,dim);
data_size = 1;
for(idx=0; idx < dim; idx++) {
dimensions[idx] = generate_random_bound_int(10,1024,&iseed);
data_size*=dimensions[idx];
}
data = DANU_MALLOC(int,data_size);
read_data = DANU_MALLOC(int,data_size);
generate_random_int_data(data,data_size,&iseed);
data_write_int(sid,data_name,dim, dimensions,data);
output_file_close(&fid);
open_file(&fid,&sid);
data_read_int(sid,data_name,dim,dimensions,read_data);
fail_unless(memcmp(read_data,data,sizeof(int)*data_size) == 0,
"Failed to read correct INT data");
DANU_FREE(dimensions);
DANU_FREE(data);
DANU_FREE(read_data);
file_delete();
}
int sparse_file_write(struct sparse_file *s, int fd, bool gz, bool sparse,
bool crc)
{
int ret;
int chunks;
struct output_file *out;
chunks = sparse_count_chunks(s);
out = output_file_open_fd(fd, s->block_size, s->len, gz, sparse, chunks, crc);
if (!out)
return -ENOMEM;
ret = write_all_blocks(s, out);
output_file_close(out);
return ret;
}
int sparse_file_callback(struct sparse_file *s, bool sparse, bool crc,
int (*write)(void *priv, const void *data, int len), void *priv)
{
int ret;
int chunks;
struct output_file *out;
chunks = sparse_count_chunks(s);
out = output_file_open_callback(write, priv, s->block_size, s->len, false,
sparse, chunks, crc);
if (!out)
return -ENOMEM;
ret = write_all_blocks(s, out);
output_file_close(out);
return ret;
}
int64_t sparse_file_len(struct sparse_file *s, bool sparse, bool crc)
{
int ret;
int chunks = sparse_count_chunks(s);
int64_t count = 0;
struct output_file *out;
out = output_file_open_callback(out_counter_write, &count,
s->block_size, s->len, false, sparse, chunks, crc);
if (!out) {
return -1;
}
ret = write_all_blocks(s, out);
output_file_close(out);
if (ret < 0) {
return -1;
}
return count;
}
END_TEST
START_TEST (test_unstruct_mesh_create)
{
const char test_file[] = FILENAME;
hid_t fid,mid;
herr_t status = output_file_create(test_file,&fid);
char mesh_name[64];
telem_t elem;
fail_unless ( H5_ISA_VALID_ID(fid),
"Failed to create output file. Invalid H5 ID");
if ( H5_ISA_VALID_ID(fid) ) {
elem = -2;
sprintf(mesh_name,"Failed Mesh");
status = mesh_create(fid,mesh_name,UNSTRUCTURED_MESH,elem,&mid);
fail_unless( status != DANU_SUCCESS,
"Failed to flag bad elem type");
/* Create mesh for each element type */
for(elem=LINE_ELEM; elem <= HEX_ELEM; elem++) {
sprintf(mesh_name,"%s elemtype=%d",MESHNAME, elem);
status = mesh_create(fid,mesh_name,UNSTRUCTURED_MESH,elem,&mid);
fail_unless( status == DANU_SUCCESS,
"Failed to create 2D unstructured mesh");
}
output_file_close(&fid);
danu_file_delete(test_file);
}
}
END_TEST
START_TEST(test_nsdata_exists)
{
hid_t fid, sid;
herr_t err;
char data_name[] = "Data DNE";
int exists;
int iseed = 0x44508;
int data;
int size;
generate_output_file(&fid,&sid);
err = data_exists(sid,data_name,&exists);
fail_unless(H5_RETURN_OK(err),
"Failed to return success status");
fail_unless(exists == 0,
"Failed to return correct exists flag (F)");
data = generate_random_int(&iseed);
size = 1;
data_write_int(sid,data_name,1,&size,&data);
err = data_exists(sid,data_name,&exists);
fail_unless(H5_RETURN_OK(err),
"Failed to return success status");
fail_unless(exists != 0,
"Failed to return correct exists flag (T)");
danu_group_close(sid);
output_file_close(&fid);
file_delete();
}
END_TEST
START_TEST(test_nsdata_list)
{
hid_t fid, sid;
herr_t err;
int iseed = 0xaa44;
char **data_names;
char **read_names;
int gen_cnt, read_size, idx, num_found;
int data;
int size;
generate_output_file(&fid,&sid);
data = generate_random_int(&iseed);
size = 1;
gen_cnt = generate_random_bound_int(10,1024,&iseed);
data_names = DANU_MALLOC(char *, gen_cnt);
for(idx=0; idx < gen_cnt; idx++) {
data_names[idx] = DANU_MALLOC(char, 32);
sprintf(data_names[idx], "Data Mu %04d",idx);
data_write_int(sid,data_names[idx],1,&size,&data);
}
read_names = DANU_MALLOC(char *, gen_cnt);
err = data_list(sid,gen_cnt,read_names,&num_found);
fail_unless(H5_RETURN_OK(err),
"Failed to return success status");
fail_unless(num_found == gen_cnt,
"Failed to find the correct number in data_list");
fail_unless(char_array_cmp(read_names,data_names,gen_cnt) == 0,
"Failed to read data names");
DANU_FREE(read_names);
read_size = gen_cnt / 2;
read_names = DANU_MALLOC(char *, read_size);
err = data_list(sid,read_size,read_names, &num_found);
fail_unless(H5_RETURN_FAIL(err),
"Failed to return fail status when array too small");
fail_unless(num_found == gen_cnt,
"Failed to find correct number in data_list");
fail_unless(char_array_cmp(read_names,data_names,read_size) == 0,
"Failed to read data names");
danu_group_close(sid);
output_file_close(&fid);
file_delete();
}
