h5varlen.cpp

Go to the documentation of this file.

#include "moab/Core.hpp"
#include "TestUtil.hpp"
#include "moab/Range.hpp"

#ifdef MOAB_HAVE_MPI
#include "moab_mpi.h"
#endif

#include <cstdlib>
#include <cstdio>

using namespace moab;

static bool keep_files = false;

void test_var_length_no_data();

void test_var_length_data();

void test_var_length_data_big();

void test_var_length_big_data();

void test_var_length_opaque();

void test_var_length_mesh_data();

void test_var_length_default_data();

void test_var_length_mesh_opaque();

void test_var_length_default_opaque();

void test_var_length_handle_tag();

void test_huge_var_length();

void create_mesh( Interface& mb );

void create_big_mesh( Interface& mb );

void compare_tags( const char* name, Interface& mb1, Interface& mb2 );

void read_write( const char* filename, Interface& write, Interface& reader );

#define CHECK_ERR_FILE( ERRCODE, FILENAME )                                \
    do                                                                     \
    {                                                                      \
        if( MB_SUCCESS != ( ERRCODE ) && !keep_files ) remove( FILENAME ); \
        CHECK_ERR( ERRCODE );                                              \
        while( false )

int main( int argc, char* argv[] )
{
#ifdef MOAB_HAVE_MPI
    int fail = MPI_Init( &argc, &argv );
    if( fail ) return fail;
#endif

    if( argc != 1 )
    {
        if( argc != 2 || strcmp( argv[1], "-k" ) != 0 )
        {
            fprintf( stderr, "Usage: %s [-k]\n", argv[0] );
            abort();
        }
        keep_files = true;
    }

    int err_count = 0;
    err_count += RUN_TEST( test_var_length_no_data );
    err_count += RUN_TEST( test_var_length_data );
    err_count += RUN_TEST( test_var_length_big_data );
    err_count += RUN_TEST( test_var_length_opaque );
    err_count += RUN_TEST( test_var_length_mesh_data );
    err_count += RUN_TEST( test_var_length_default_data );
    err_count += RUN_TEST( test_var_length_mesh_opaque );
    err_count += RUN_TEST( test_var_length_default_opaque );
    err_count += RUN_TEST( test_var_length_handle_tag );
    err_count += RUN_TEST( test_var_length_data_big );

    err_count += RUN_TEST( test_huge_var_length );

#ifdef MOAB_HAVE_MPI
    fail = MPI_Finalize();
    if( fail ) return fail;
#endif

    return err_count;
}

void test_var_length_no_data()
{
    ErrorCode rval;
    Core moab1, moab2;
    Interface &mb1 = moab1, &mb2 = moab2;
    Tag tag;

    create_mesh( mb1 );
    rval = mb1.tag_get_handle( "test_tag", 0, MB_TYPE_DOUBLE, tag, MB_TAG_EXCL | MB_TAG_VARLEN | MB_TAG_DENSE );CHECK_ERR( rval );

    read_write( "test_var_length_no_data.h5m", mb1, mb2 );
    compare_tags( "test_tag", mb1, mb2 );
}

void test_var_length_data_common( const char* filename, Interface& mb1, bool opaque = false )
{
    // create tag
    ErrorCode rval;
    Tag tag;
    DataType type = opaque ? MB_TYPE_OPAQUE : MB_TYPE_INTEGER;
    rval          = mb1.tag_get_handle( "test_tag", 0, type, tag, MB_TAG_EXCL | MB_TAG_VARLEN | MB_TAG_SPARSE );CHECK_ERR( rval );

    // get all entities
    Range entities;
    rval = mb1.get_entities_by_handle( 0, entities );CHECK_ERR( rval );

    // Set tag data.
    // Tag data will be list of integer data as follows:
    //   number of values (counting this value)
    //   step, 2*step, 3*step, ...
    for( Range::const_iterator i = entities.begin(); i != entities.end(); ++i )
    {
        EntityHandle h = *i;
        // generate some data to write
        int num_values   = h % 6 + 1;
        EntityType etype = mb1.type_from_handle( h );
        int step         = ( h % 2 ) ? 1 + (int)etype : -1 - (int)etype;
        std::vector< int > tag_data( num_values, num_values );
        for( int j = 1; j < num_values; ++j )
            tag_data[j] = j * step;
        // set tag data
        const void* ptrarr[] = { &tag_data[0] };
        if( opaque ) num_values *= sizeof( int );
        rval = mb1.tag_set_by_ptr( tag, &h, 1, ptrarr, &num_values );CHECK_ERR( rval );
    }

    // write and read tag data
    Core moab;
    Interface& mb2 = moab;
    read_write( filename, mb1, mb2 );
    compare_tags( "test_tag", mb1, mb2 );

    // get new tag handle
    tag  = 0;
    rval = mb2.tag_get_handle( "test_tag", 0, type, tag );CHECK_ERR( rval );

    // check consistency of tag values
    entities.clear();
    mb2.get_entities_by_handle( 0, entities );
    // remove sets created during read/write process
    Range sets;
    mb2.get_entities_by_type( 0, MBENTITYSET, sets );
    entities = subtract( entities, sets );
    for( Range::const_iterator i = entities.begin(); i != entities.end(); ++i )
    {
        // get data
        const void* ptrarr[] = { NULL };
        int size;
        rval = mb2.tag_get_by_ptr( tag, &*i, 1, ptrarr, &size );CHECK_ERR( rval );
        if( opaque )
        {
            CHECK_EQUAL( (size_t)0, size % sizeof( int ) );
            size /= sizeof( int );
        }
        const int* dataptr = reinterpret_cast< const int* >( ptrarr[0] );
        CHECK( NULL != dataptr );
        // check size
        CHECK( size > 0 );
        CHECK_EQUAL( size, dataptr[0] );
        // check other values
        if( size > 2 )
        {
            int step = dataptr[1];
            for( int j = 2; j < size; ++j )
                CHECK_EQUAL( j * step, dataptr[j] );
        }
    }
}

void test_var_length_data()
{
    Core moab;
    create_mesh( moab );
    test_var_length_data_common( "test_var_length_data.h5m", moab );
}

void test_var_length_data_big()
{
    Core moab;
    create_big_mesh( moab );
    test_var_length_data_common( "test_var_length_data_big.h5m", moab );
}

void calculate_big_value( Interface& moab, EntityHandle vert, size_t size, double* data )
{
    // Make values like Fibonacci numbers, except use X and Y coords
    // rather than 0 and 1 as first two values.

    CHECK( size >= 3 );
    ErrorCode rval = moab.get_coords( &vert, 1, data );CHECK_ERR( rval );

    for( size_t j = 2; j < size; ++j )
        data[j] = data[j - 2] + data[j - 1];CHECK_ERR( rval );
}

void test_var_length_big_data()
{
    ErrorCode rval;
    Core moab1, moab2;
    Interface &mb1 = moab1, &mb2 = moab2;
    Tag tag;

    create_mesh( mb1 );
    rval = mb1.tag_get_handle( "test_tag", 0, MB_TYPE_DOUBLE, tag, MB_TAG_SPARSE | MB_TAG_VARLEN | MB_TAG_EXCL );CHECK_ERR( rval );

    // choose 3 vertices upon which to set data
    Range range;
    rval = mb1.get_entities_by_type( 0, MBVERTEX, range );CHECK_ERR( rval );
    EntityHandle verts[3] = { range.front(), *( range.begin() += range.size() / 3 ),
                              *( range.begin() += 2 * range.size() / 3 ) };

    // set 1-millon value tag data on three vertices
    std::vector< double > data( 1000000 );
    for( int i = 0; i < 3; ++i )
    {
        calculate_big_value( mb1, verts[i], data.size(), &data[0] );
        const void* ptr = &data[0];
        const int size  = data.size();
        rval            = mb1.tag_set_by_ptr( tag, verts + i, 1, &ptr, &size );CHECK_ERR( rval );
    }

    read_write( "test_var_length_big_data.h5m", mb1, mb2 );
    compare_tags( "test_tag", mb1, mb2 );

    // check 3 tagged vertices
    rval = mb2.tag_get_handle( "test_tag", 0, MB_TYPE_DOUBLE, tag );CHECK_ERR( rval );
    range.clear();
    rval = mb2.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, 0, 1, range, Interface::UNION );CHECK_ERR( rval );
    CHECK_EQUAL( (size_t)3, range.size() );

    // check tag values
    for( Range::const_iterator i = range.begin(); i != range.end(); ++i )
    {
        // calculate expected value
        const EntityHandle h = *i;
        calculate_big_value( mb2, h, data.size(), &data[0] );

        // get actual value
        const void* ptr;
        int size;
        rval = mb2.tag_get_by_ptr( tag, &h, 1, &ptr, &size );CHECK_ERR( rval );
        CHECK_EQUAL( data.size(), (size_t)size );

        // compare values
        const double* act_data = reinterpret_cast< const double* >( ptr );
        int wrong_count        = 0;
        for( size_t j = 0; j < data.size(); ++j )
            if( act_data[j] != data[j] ) ++wrong_count;
        CHECK_EQUAL( 0, wrong_count );
    }
}

void test_var_length_opaque()
{
    Core moab;
    create_mesh( moab );
    test_var_length_data_common( "test_var_length_opaque.h5m", moab, true );
}

void test_global_value_common( bool mesh_value )
{
    Core moab;
    Interface& mb = moab;
    create_mesh( mb );

    // get three vertices
    Range vertices;
    ErrorCode rval = mb.get_entities_by_type( 0, MBVERTEX, vertices );CHECK_ERR( rval );
    CHECK( vertices.size() >= 3 );
    EntityHandle handles[3];
    Range::const_iterator i = vertices.begin();
    handles[0]              = *i;
    ++i;
    handles[1] = *i;
    ++i;
    handles[2] = *i;
    ++i;

    // get vertex coordinates
    double coords[9];
    rval = mb.get_coords( handles, 3, coords );CHECK_ERR( rval );

    // create tag to hold vertex data
    Tag handle_tag       = 0;
    void* default_val    = mesh_value ? 0 : handles;
    int default_val_size = mesh_value ? 0 : 3;
    rval                 = mb.tag_get_handle( "handle_tag", default_val_size, MB_TYPE_HANDLE, handle_tag,
                                              MB_TAG_DENSE | MB_TAG_VARLEN | MB_TAG_EXCL, default_val );CHECK_ERR( rval );

    // create tag to hold vertex coordinates
    Tag coord_tag    = 0;
    default_val      = mesh_value ? 0 : coords;
    default_val_size = mesh_value ? 0 : 9;
    rval             = mb.tag_get_handle( "coord_tag", default_val_size, MB_TYPE_DOUBLE, coord_tag,
                                          MB_TAG_SPARSE | MB_TAG_VARLEN | MB_TAG_EXCL, default_val );CHECK_ERR( rval );

    // if doing mesh tag, set it
    if( mesh_value )
    {
        int size                = 3;
        const void* ptrarr[]    = { handles };
        const EntityHandle root = 0;
        rval                    = mb.tag_set_by_ptr( handle_tag, &root, 1, ptrarr, &size );CHECK_ERR( rval );

        size      = 9;
        ptrarr[0] = coords;
        rval      = mb.tag_set_by_ptr( coord_tag, &root, 1, ptrarr, &size );CHECK_ERR( rval );
    }

    // write and read file
    Core moab2;
    Interface& mb2 = moab2;
    read_write( mesh_value ? "test_var_length_mesh_data.h5m" : "test_var_length_default_data.h5m", mb, mb2 );
    compare_tags( "handle_tag", mb, mb2 );
    compare_tags( "coord_tag", mb, mb2 );

    // get tag handles
    handle_tag = coord_tag = 0;
    rval                   = mb2.tag_get_handle( "handle_tag", 0, MB_TYPE_HANDLE, handle_tag );CHECK_ERR( rval );
    rval = mb2.tag_get_handle( "coord_tag", 0, MB_TYPE_DOUBLE, coord_tag );CHECK_ERR( rval );

    // get tag data
    int handle_tag_size = 0, coord_tag_size = 0;
    const void* ptrs[2];
    if( mesh_value )
    {
        const EntityHandle root = 0;
        rval                    = mb2.tag_get_by_ptr( handle_tag, &root, 1, ptrs, &handle_tag_size );CHECK_ERR( rval );
        rval = mb2.tag_get_by_ptr( coord_tag, &root, 1, ptrs + 1, &coord_tag_size );CHECK_ERR( rval );
    }
    else
    {
        rval = mb2.tag_get_default_value( handle_tag, ptrs[0], handle_tag_size );CHECK_ERR( rval );
        rval = mb2.tag_get_default_value( coord_tag, ptrs[1], coord_tag_size );CHECK_ERR( rval );
    }

    // check expected sizes
    CHECK_EQUAL( 3, handle_tag_size );
    CHECK_EQUAL( 9, coord_tag_size );
    CHECK( ptrs[0] != NULL );
    CHECK( ptrs[1] != NULL );

    // check valid handles
    const EntityHandle* handle_vals = reinterpret_cast< const EntityHandle* >( ptrs[0] );
    CHECK( handle_vals[0] != 0 );
    CHECK( handle_vals[1] != 0 );
    CHECK( handle_vals[2] != 0 );
    CHECK_EQUAL( MBVERTEX, mb2.type_from_handle( handle_vals[0] ) );
    CHECK_EQUAL( MBVERTEX, mb2.type_from_handle( handle_vals[1] ) );
    CHECK_EQUAL( MBVERTEX, mb2.type_from_handle( handle_vals[2] ) );

    // check correct coordinate values
    const double* coord_vals = reinterpret_cast< const double* >( ptrs[1] );
    rval                     = mb2.get_coords( handle_vals, 3, coords );CHECK_ERR( rval );
    CHECK_REAL_EQUAL( coords[0], coord_vals[0], 1e-12 );
    CHECK_REAL_EQUAL( coords[1], coord_vals[1], 1e-12 );
    CHECK_REAL_EQUAL( coords[2], coord_vals[2], 1e-12 );
    CHECK_REAL_EQUAL( coords[3], coord_vals[3], 1e-12 );
    CHECK_REAL_EQUAL( coords[4], coord_vals[4], 1e-12 );
    CHECK_REAL_EQUAL( coords[5], coord_vals[5], 1e-12 );
    CHECK_REAL_EQUAL( coords[6], coord_vals[6], 1e-12 );
    CHECK_REAL_EQUAL( coords[7], coord_vals[7], 1e-12 );
    CHECK_REAL_EQUAL( coords[8], coord_vals[8], 1e-12 );
}

void test_var_length_mesh_data()
{
    test_global_value_common( true );
}

void test_var_length_default_data()
{
    test_global_value_common( false );
}

void test_global_opaque_common( bool mesh_value )
{
    ErrorCode rval;
    Core moab;
    Interface& mb = moab;
    create_mesh( mb );

    const char data[] = { 'J', 'A', 'S', 'O', 'N' };
    const int datalen = sizeof( data );
    CHECK_EQUAL( 5, datalen );

    // create tag
    Tag tag                 = 0;
    const void* default_val = mesh_value ? 0 : data;
    int default_val_size    = mesh_value ? 0 : datalen;
    rval                    = mb.tag_get_handle( "opaque_tag", default_val_size, MB_TYPE_OPAQUE, tag,
                                                 MB_TAG_DENSE | MB_TAG_VARLEN | MB_TAG_EXCL, default_val );CHECK_ERR( rval );

    // if doing mesh tag, set it
    if( mesh_value )
    {
        const void* ptrarr[]    = { data };
        const EntityHandle root = 0;
        rval                    = mb.tag_set_by_ptr( tag, &root, 1, ptrarr, &datalen );CHECK_ERR( rval );
    }

    // write and read file
    Core moab2;
    Interface& mb2 = moab2;
    read_write( mesh_value ? "test_var_length_mesh_opaque.h5m" : "test_var_length_default_opaque.h5m", mb, mb2 );
    compare_tags( "opaque_tag", mb, mb2 );

    // get tag handles
    tag  = 0;
    rval = mb2.tag_get_handle( "opaque_tag", 0, MB_TYPE_OPAQUE, tag );CHECK_ERR( rval );

    // get tag data
    int tag_size = 0;
    const void* ptrs[1];
    if( mesh_value )
    {
        const EntityHandle root = 0;
        rval                    = mb2.tag_get_by_ptr( tag, &root, 1, ptrs, &tag_size );CHECK_ERR( rval );
    }
    else
    {
        rval = mb2.tag_get_default_value( tag, ptrs[0], tag_size );CHECK_ERR( rval );
    }

    // check size
    CHECK_EQUAL( datalen, tag_size );
    CHECK( ptrs[0] != NULL );

    // check values
    const char* tag_data = reinterpret_cast< const char* >( ptrs[0] );
    for( int i = 0; i < datalen; ++i )
        CHECK_EQUAL( data[i], tag_data[i] );
}

void test_var_length_mesh_opaque()
{
    test_global_opaque_common( true );
}

void test_var_length_default_opaque()
{
    test_global_opaque_common( false );
}

void test_var_length_handle_tag()
{
    ErrorCode rval;
    Core moab1, moab2;
    Interface &mb1 = moab1, &mb2 = moab2;
    Tag tag;
    Range::const_iterator i;

    create_mesh( mb1 );
    rval = mb1.tag_get_handle( "test_tag", 0, MB_TYPE_HANDLE, tag, MB_TAG_SPARSE | MB_TAG_VARLEN | MB_TAG_EXCL );CHECK_ERR( rval );

    // Get all entities
    Range range;
    rval = mb1.get_entities_by_handle( 0, range );CHECK_ERR( rval );

    // For each entity, if it is a vertex store its own handle
    // in its tag.  Otherwise store the element connectivity list
    // in the tag.  Skip entity sets.
    size_t num_tagged_entities = 0;
    for( i = range.begin(); i != range.end(); ++i )
    {
        EntityHandle h  = *i;
        EntityType type = mb1.type_from_handle( h );
        if( type == MBVERTEX )
        {
            const int size  = 1;
            const void* ptr = &h;
            rval            = mb1.tag_set_by_ptr( tag, &h, 1, &ptr, &size );CHECK_ERR( rval );
            ++num_tagged_entities;
        }
        else if( type != MBENTITYSET )
        {
            int size                 = 0;
            const EntityHandle* conn = 0;
            rval                     = mb1.get_connectivity( h, conn, size );CHECK_ERR( rval );
            const void* ptr = conn;
            rval            = mb1.tag_set_by_ptr( tag, &h, 1, &ptr, &size );CHECK_ERR( rval );
            ++num_tagged_entities;
        }
    }

    read_write( "test_var_length_handle_tag.h5m", mb1, mb2 );
    compare_tags( "test_tag", mb1, mb2 );

    // check number of tagged entities
    rval = mb2.tag_get_handle( "test_tag", 0, MB_TYPE_HANDLE, tag );CHECK_ERR( rval );
    range.clear();
    for( EntityType t = MBVERTEX; t != MBENTITYSET; ++t )
    {
        rval = mb2.get_entities_by_type_and_tag( 0, t, &tag, 0, 1, range, Interface::UNION );CHECK_ERR( rval );
    }
    CHECK_EQUAL( num_tagged_entities, range.size() );

    // check tag values
    for( i = range.begin(); i != range.end(); ++i )
    {
        EntityHandle h = *i;

        const void* ptr;
        int size;
        rval = mb2.tag_get_by_ptr( tag, &h, 1, &ptr, &size );CHECK_ERR( rval );

        const EntityHandle* handles = reinterpret_cast< const EntityHandle* >( ptr );

        if( mb2.type_from_handle( h ) == MBVERTEX )
        {
            CHECK_EQUAL( 1, size );
            CHECK_EQUAL( h, *handles );
        }
        else
        {
            int len;
            const EntityHandle* conn;
            rval = mb2.get_connectivity( h, conn, len );CHECK_ERR( rval );
            CHECK_EQUAL( len, size );
            for( int j = 0; j < len; ++j )
                CHECK_EQUAL( conn[j], handles[j] );
        }
    }
}

void test_huge_var_length()
{
    ErrorCode rval;
    Core moab1, moab2;
    Interface &mb1 = moab1, &mb2 = moab2;
    Tag tag;
    Range::const_iterator i;

    create_mesh( mb1 );
    rval = mb1.tag_get_handle( "test_tag", 0, MB_TYPE_DOUBLE, tag, MB_TAG_SPARSE | MB_TAG_VARLEN | MB_TAG_EXCL );CHECK_ERR( rval );

    // Get all entities
    Range range;
    rval = mb1.get_entities_by_handle( 0, range );CHECK_ERR( rval );

    // For each entity, if it is a vertex store its own handle
    // in its tag.  Otherwise store the element connectivity list
    // in the tag.  Skip entity sets.
    EntityHandle v1 = range[0];  // first vertex
    // huge data
    std::vector< double > dataArr;  // larger than the buffer
    int N = 2000;
    dataArr.resize( N );  // size will be 8 * N > bufferSize = 10000 set by option during writing
    for( int j = 0; j < N; j++ )
        dataArr[j] = j;
    const void* ptr = &dataArr[0];
    rval            = mb1.tag_set_by_ptr( tag, &v1, 1, &ptr, &N );CHECK_ERR( rval );
    // second vertex, do a smaller N
    v1    = range[1];
    int M = N - 5;
    ptr   = &dataArr[2];  // start with 2
    rval  = mb1.tag_set_by_ptr( tag, &v1, 1, &ptr, &M );CHECK_ERR( rval );

    // write with a smaller buffer, size controlled by option to test
    const char* writeOptions = "BUFFER_SIZE=4000;DEBUG_IO=5";
    rval                     = mb1.write_file( "test_huge_var_tag.h5m", NULL, writeOptions );CHECK_ERR( rval );
    rval = mb2.load_file( "test_huge_var_tag.h5m" );CHECK_ERR( rval );
    compare_tags( "test_tag", mb1, mb2 );
    // compare some values for the 2nd vertex
    Tag tag2;
    rval = mb2.tag_get_handle( "test_tag", tag2 );CHECK_ERR( rval );
    EntityHandle vertex2 = 2;
    int len2;
    const void* ptr2;
    rval = mb2.tag_get_by_ptr( tag2, &vertex2, 1, &ptr2, &len2 );CHECK_ERR( rval );
    CHECK_EQUAL( len2, M );

    CHECK_REAL_EQUAL( dataArr[2], ( (double*)ptr2 )[0], 0.000000001 );

    if( !keep_files ) remove( "test_huge_var_tag.h5m" );CHECK_ERR( rval );
}
void create_structured_quad_mesh( Interface& mb, int x, int y )
{
    ErrorCode rval;

    const double z = 2.1;
    std::vector< EntityHandle > verts( ( x + 1 ) * ( y + 1 ) );
    for( int i = 0; i <= x; ++i )
    {
        for( int j = 0; j <= y; ++j )
        {
            double coords[3] = { static_cast< double >( i ), static_cast< double >( j ), static_cast< double >( z ) };
            rval             = mb.create_vertex( coords, verts[i + ( x + 1 ) * j] );CHECK_ERR( rval );
        }
    }

    std::vector< EntityHandle > elems( x * y );
    for( int i = 0; i < x; ++i )
    {
        for( int j = 0; j < y; ++j )
        {
            EntityHandle conn[4] = { verts[i + ( x + 1 ) * j], verts[i + 1 + ( x + 1 ) * j],
                                     verts[i + 1 + ( x + 1 ) * ( j + 1 )], verts[i + ( x + 1 ) * ( j + 1 )] };
            rval                 = mb.create_element( MBQUAD, conn, 4, elems[i + x * j] );CHECK_ERR( rval );
        }
    }
}

void create_mesh( Interface& mb )
{
    create_structured_quad_mesh( mb, 2, 2 );
}

void create_big_mesh( Interface& mb )
{
    create_structured_quad_mesh( mb, 300, 300 );
}

void compare_tags( const char* name, Interface& mb1, Interface& mb2 )
{
    ErrorCode rval;
    Tag tag1, tag2;
    rval = mb1.tag_get_handle( name, 0, MB_TYPE_OPAQUE, tag1, MB_TAG_ANY );CHECK_ERR( rval );
    rval = mb2.tag_get_handle( name, 0, MB_TYPE_OPAQUE, tag2, MB_TAG_ANY );CHECK_ERR( rval );

    int size;
    CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, mb1.tag_get_length( tag1, size ) );
    CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, mb2.tag_get_length( tag2, size ) );

    TagType storage1, storage2;
    rval = mb1.tag_get_type( tag1, storage1 );CHECK_ERR( rval );
    rval = mb2.tag_get_type( tag2, storage2 );CHECK_ERR( rval );
    CHECK_EQUAL( storage1, storage2 );

    DataType type1, type2;
    rval = mb1.tag_get_data_type( tag1, type1 );CHECK_ERR( rval );
    rval = mb2.tag_get_data_type( tag2, type2 );CHECK_ERR( rval );

    const void *defval1, *defval2;
    int defsize1, defsize2;
    ErrorCode rval1 = mb1.tag_get_default_value( tag1, defval1, defsize1 );
    ErrorCode rval2 = mb2.tag_get_default_value( tag2, defval2, defsize2 );
    if( MB_SUCCESS == rval1 )
    {
        CHECK_ERR( rval2 );

        CHECK_EQUAL( defsize1, defsize2 );
        CHECK( !memcmp( defval1, defval2, defsize1 ) );
    }
    else if( MB_ENTITY_NOT_FOUND == rval1 || MB_TAG_NOT_FOUND == rval1 )
        CHECK_EQUAL( rval1, rval2 );
    else
        CHECK_ERR( rval1 );
}

void read_write( const char* filename, Interface& writer, Interface& reader )
{
    ErrorCode rval = writer.write_file( filename );
    if( !keep_files && MB_SUCCESS != rval ) remove( filename );CHECK_ERR( rval );
    rval = reader.load_mesh( filename );
    if( !keep_files ) remove( filename );CHECK_ERR( rval );
}