internals_test.cpp

Go to the documentation of this file.

#include "Internals.hpp"
#include <iostream>
using namespace std;

using namespace moab;

HandleUtils handleUtils( 0, 1 );

bool internal_assert( bool c )
{
    return !c;
}

#define handle_test_assert( C )                  \
    if( internal_assert( C ) )                   \
    {                                            \
        cout << "Test: " #C " failed ." << endl; \
        return false;                            \
    }

bool handle_test( EntityType type, EntityID id, int proc, bool should_fail )
{
    int err             = 0;
    EntityHandle handle = CREATE_HANDLE( type, handleUtils.create_id( id, proc ), err );
    if( should_fail )
    {
        handle_test_assert( err ) return true;
    }
    handle_test_assert( !err )

        EntityType type_from_handle = TYPE_FROM_HANDLE( handle );
    handle_test_assert( type_from_handle == type )

        EntityID id_from_handle = handleUtils.id_from_handle( handle );
    handle_test_assert( id_from_handle == id )

        int proc_from_handle = handleUtils.rank_from_handle( handle );
    handle_test_assert( proc_from_handle == proc )

        return true;
}

#define tag_test_assert( C )                    \
    if( internal_assert( C ) )                  \
    {                                           \
        cout << "Test: " #C " failed." << endl; \
        return false;                           \
    }

bool tag_test( TagId id, TagType prop )
{
    Tag tag = TAG_HANDLE_FROM_ID( id, prop );

    unsigned long id_from_handle = ID_FROM_TAG_HANDLE( tag );
    tag_test_assert( id_from_handle == id )

        TagType prop_from_handle = PROP_FROM_TAG_HANDLE( tag );
    tag_test_assert( prop_from_handle == prop )

        return true;
}

//! Sample code on a 32-bit system.
int main()
{
    const unsigned cpus[] = { 1, 4, 16, 5, 20 };
    const int num_cpus    = sizeof( cpus ) / sizeof( cpus[0] );
    unsigned errors = 0, tests = 0;
    const int num_prop = MB_TAG_LAST + 1;

    ++tests;
    if( MB_TAG_LAST > num_prop )
    {
        cout << "MB_TAG_PROP_WIDTH insufficient for size of TagType" << endl;
        ++errors;
    }

    ++tests;
    if( MBMAXTYPE > 1 << MB_TYPE_WIDTH )
    {
        cout << "MB_TYPE_WIDTH insufficient for size of EntityType" << endl;
        ++errors;
    }

    // if any errors so far, abort because everything else will
    // probably fail.
    if( errors ) return errors;

    for( int num_cpu = 0; num_cpu < num_cpus; ++num_cpu )
    {

        handleUtils = HandleUtils( 0, cpus[num_cpu] );

        // init these after setting num_cpu, because max id depends on num cpu.
        const EntityID ids[] = { 0, 1, handleUtils.max_id() / 2, handleUtils.max_id() - 1, handleUtils.max_id() };
        const TagId tids[]   = { 0, 1, MB_TAG_PROP_MASK / 2, MB_TAG_PROP_MASK - 1, MB_TAG_PROP_MASK };
        const int num_ids    = sizeof( ids ) / sizeof( ids[0] );
        const int num_tids   = sizeof( tids ) / sizeof( tids[0] );

        for( unsigned cpu = 0; cpu < cpus[num_cpu]; ++cpu )
        {
            for( EntityType type = MBVERTEX; type < MBMAXTYPE; ++type )
                for( int id = 0; id < num_ids; ++id )
                {
                    ++tests;
                    if( !handle_test( type, ids[id], cpu, false ) )
                    {
                        cout << "Test of handle with type=" << type << ", id=" << ids[id] << ", proc=" << cpu
                             << ", and numproc=" << cpus[num_cpu] << endl;
                        ++errors;
                    }
                }

            for( int prop = 0; prop < num_prop; ++prop )
                for( int id = 0; id < num_tids; ++id )
                {
                    ++tests;
                    if( !tag_test( tids[id], (TagType)prop ) )
                    {
                        cout << "Test of tag handle with prop=" << prop << ", id=" << tids[id] << ", proc=" << cpu
                             << ", and numproc=" << cpus[num_cpu] << endl;
                        ++errors;
                    }
                }
        }
    }

    // test some stuff that should fail
    handleUtils = HandleUtils( 0, 16 );
    ++tests;
    if( !handle_test( MBVERTEX, MB_END_ID + 1, 0, true ) )
    {
        cout << "Failed to catch ID overflow" << endl;
        ++errors;
    }
    ++tests;
    if( !handle_test( (EntityType)( MBMAXTYPE + 1 ), 1, 0, true ) )
    {
        cout << "Failed to catch type overflow" << endl;
        ++errors;
    }
    //  ++tests;
    //  if (!handle_test( MBHEX, 1, 17, true)) {
    //    cout << "Failed to catch Proc# overflow" << endl;
    //    ++errors;
    //  }

    if( errors )
        cout << endl << errors << " of " << tests << " tests failed." << endl << endl;
    else
        cout << endl << tests << " tests passed." << endl << endl;
    return errors;
}