MOAB: Mesh Oriented datABase  (version 5.2.1)
test_entsetFB.cpp
Go to the documentation of this file.
00001 #include "moab/MOABConfig.h"
00002 #include "FBiGeom.h"
00003 #include "iMesh.h"
00004 #include "iRel.h"
00005 
00006 #include "stdio.h"
00007 #include "stdlib.h"
00008 #include "string.h"
00009 
00010 #define DEFAULT_TEST_FILE  shell.h5m
00011 #define DEFAULT_TEST_FILE1 shellQuad.h5m
00012 
00013 // clang-format off
00014 
00015 #define STRINGIFY_( X ) #X
00016 #define STRINGIFY( X )  STRINGIFY_( X )
00017 #if defined( MESHDIR ) && defined( MOAB_HAVE_HDF5 )
00018 #define DEFAULT_INPUT_FILE  STRINGIFY( MESHDIR/fbigeom/DEFAULT_TEST_FILE )
00019 #define DEFAULT_INPUT_FILE1 STRINGIFY( MESHDIR/fbigeom/DEFAULT_TEST_FILE1 )
00020 #else
00021 #error Specify MESHDIR to compile test
00022 #endif
00023 
00024 #define CHECK_SIZE_C( type, array, allocated_size, size )            \
00025     if( NULL == *array || *allocated_size == 0 )                     \
00026     {                                                                \
00027         *array          = (type*)malloc( sizeof( type ) * size );    \
00028         *allocated_size = size;                                      \
00029     }                                                                \
00030     else if( *allocated_size < size )                                \
00031     {                                                                \
00032         printf( "   Array passed in is non-zero but too short.\n" ); \
00033     }
00034 
00035 // clang-format on
00036 
00037 typedef void* iRel_EntityHandle;
00038 
00039 /*!
00040   prints out a result string based on the value of error_code
00041 */
00042 void handle_error_code( const int result, int* number_failed, int* number_not_implemented, int* number_successful )
00043 {
00044     if( result )
00045     {
00046         printf( "Success" );
00047         ( *number_successful )++;
00048     }
00049     else
00050     {
00051         printf( "Failure" );
00052         ( *number_failed )++;
00053     }
00054 }
00055 
00056 int print_geom_info( FBiGeom_Instance geom, iBase_EntityHandle gent )
00057 {
00058     /* print information about this entity */
00059     int ent_type;
00060     int result;
00061     const char* type_names[] = { "Vertex", "Edge", "Face", "Region" };
00062 
00063     FBiGeom_getEntType( geom, gent, &ent_type, &result );
00064 
00065     if( iBase_SUCCESS != result )
00066     {
00067         printf( "Trouble getting entity adjacencies or types." );
00068         return 0;
00069     }
00070 
00071     printf( "%s 0x%lx\n", type_names[ent_type], (unsigned long)gent );
00072 
00073     return 1;
00074 }
00075 
00076 int print_mesh_info( iMesh_Instance mesh, iBase_EntityHandle ment )
00077 {
00078     /* print information about this entity */
00079 
00080     /* get adjacencies first; assume not more than 50 */
00081     iBase_EntityHandle adj_ents[50], *adj_ents_ptr = adj_ents;
00082     int ent_types[50], *ent_types_ptr              = ent_types;
00083     int adj_ents_alloc = 50, adj_ents_size, ent_types_size, ent_types_allocated = 50;
00084     int result;
00085     iBase_TagHandle* ment_tags = NULL;
00086     int ment_tags_size, ment_tags_alloc;
00087     char** tag_names;
00088     int i;
00089     const char* type_names[] = { "Vertex", "Edge", "Face", "Region" };
00090     int tag_type;
00091 
00092     char* dum_handle     = NULL;
00093     int dum_handle_alloc = 0, dum_handle_size = 0;
00094     int int_data;
00095     double dbl_data;
00096     iBase_EntityHandle eh_data;
00097 
00098     iMesh_getEntAdj( mesh, ment, iBase_ALL_TYPES, &adj_ents_ptr, &adj_ents_alloc, &adj_ents_size, &result );
00099 
00100     if( iBase_SUCCESS != result ) return 0;
00101 
00102     /* put this ent on the end, then get types */
00103     adj_ents[adj_ents_size] = ment;
00104     iMesh_getEntArrType( mesh, adj_ents, adj_ents_size + 1, &ent_types_ptr, &ent_types_allocated, &ent_types_size,
00105                          &result );
00106     if( iBase_SUCCESS != result )
00107     {
00108         printf( "Trouble getting entity adjacencies or types." );
00109         return 0;
00110     }
00111 
00112     /* get tags on ment */
00113     iMesh_getAllTags( mesh, ment, &ment_tags, &ment_tags_alloc, &ment_tags_size, &result );
00114 
00115     printf( "Trouble getting tags on an entity or their names." );
00116 
00117     /* while we're at it, get all the tag names */
00118 
00119     tag_names = (char**)malloc( ment_tags_size * sizeof( char* ) );
00120 
00121     for( i = 0; i < ment_tags_size; i++ )
00122     {
00123         tag_names[i] = (char*)malloc( 120 * sizeof( char ) );
00124         iMesh_getTagName( mesh, ment_tags[i], tag_names[i], &result, 120 );
00125     }
00126 
00127     /* now print the information */
00128     printf( "%s %ld:\n", type_names[ent_types[ent_types_size - 1]], (long)ment );
00129     printf( "Adjacencies:" );
00130     for( i = 0; i < adj_ents_size; i++ )
00131     {
00132         if( i > 0 ) printf( ", " );
00133         printf( "%s %ld", type_names[ent_types[i]], (long)adj_ents[i] );
00134     }
00135     printf( "\nTags: \n" );
00136     for( i = 0; i < ment_tags_size; i++ )
00137     {
00138         printf( "%s ", tag_names[i] );
00139         iMesh_getTagType( mesh, ment_tags[i], &tag_type, &result );
00140         if( iBase_SUCCESS != result )
00141             printf( "(trouble getting type...)\n" );
00142         else
00143         {
00144             dum_handle       = NULL;
00145             dum_handle_alloc = 0, dum_handle_size = 0;
00146 
00147             switch( tag_type )
00148             {
00149                 case iBase_INTEGER:
00150                     iMesh_getIntData( mesh, ment, ment_tags[i], &int_data, &result );
00151                     printf( "(Int value=%d)", int_data );
00152                     break;
00153                 case iBase_DOUBLE:
00154                     iMesh_getDblData( mesh, ment, ment_tags[i], &dbl_data, &result );
00155                     printf( "(Dbl value=%f)", dbl_data );
00156                     break;
00157                 case iBase_ENTITY_HANDLE:
00158                     iMesh_getEHData( mesh, ment, ment_tags[i], &eh_data, &result );
00159                     printf( "(EH value=%ld)", (long)eh_data );
00160                     break;
00161                 case iBase_BYTES:
00162                     iMesh_getData( mesh, ment, ment_tags[i], (void**)&dum_handle, &dum_handle_alloc, &dum_handle_size,
00163                                    &result );
00164                     if( NULL != dum_handle && dum_handle_size > 0 ) printf( "(Opaque value=%c)", dum_handle[0] );
00165                     break;
00166             }
00167         }
00168 
00169         printf( "\n" );
00170     }
00171     printf( "(end tags)\n\n" );
00172     free( ment_tags );
00173     return 1;
00174 }
00175 
00176 /*!
00177   @test
00178   Load Mesh
00179   @li Load a geom and a mesh file
00180 */
00181 int load_geom_mesh_test( const char* geom_filename, const char* mesh_filename, FBiGeom_Instance geom,
00182                          iMesh_Instance mesh )
00183 {
00184     /* load a geom */
00185     int result;
00186     FBiGeom_load( geom, geom_filename, 0, &result, strlen( geom_filename ), 0 );
00187     if( iBase_SUCCESS != result )
00188     {
00189         printf( "ERROR : can not load a geometry\n" );
00190         return 0;
00191     }
00192 
00193     /* load a mesh */
00194     iMesh_load( mesh, 0, mesh_filename, 0, &result, strlen( mesh_filename ), 0 );
00195     if( iBase_SUCCESS != result )
00196     {
00197         printf( "ERROR : can not load a mesh\n" );
00198         return 0;
00199     }
00200 
00201     return 1;
00202 }
00203 
00204 /*!
00205   @test
00206   TSTTLasso create relation  Test
00207   @li Create relation between geom and mesh
00208 */
00209 int create_relation_test( iRel_Instance assoc, FBiGeom_Instance geom, iMesh_Instance mesh, iRel_PairHandle* pair )
00210 {
00211     int result;
00212 
00213     iBase_Instance iface1, iface2;
00214     int type1, type2;
00215     int ent_or_set1, ent_or_set2;
00216     int status1, status2;
00217 
00218     iRel_PairHandle tmp_pair;
00219     iRel_PairHandle* pair_ptr = &tmp_pair;
00220     int pairs_alloc           = 1, pairs_size;
00221 
00222     /* create an relation, entity to set */
00223     iRel_createPair( assoc, geom, iRel_ENTITY, iRel_FBIGEOM_IFACE, iRel_ACTIVE, mesh, iRel_SET, iRel_IMESH_IFACE,
00224                      iRel_ACTIVE, pair, &result );
00225     if( iBase_SUCCESS != result )
00226     {
00227         printf( "Couldn't create a new relation.\n" );
00228         return 0;
00229     }
00230 
00231     iRel_getPairInfo( assoc, *pair, &iface1, &ent_or_set1, &type1, &status1, &iface2, &ent_or_set2, &type2, &status2,
00232                       &result );
00233     if( iBase_SUCCESS != result )
00234     {
00235         printf( "Couldn't retrieve relation info.\n" );
00236         return 0;
00237     }
00238     if( iface1 != geom || ent_or_set1 != iRel_ENTITY || type1 != iRel_FBIGEOM_IFACE || iface2 != mesh ||
00239         ent_or_set2 != iRel_SET || type2 != iRel_IMESH_IFACE )
00240     {
00241         printf( "Unexpected relation info returned.\n" );
00242         return 0;
00243     }
00244 
00245     iRel_findPairs( assoc, geom, &pair_ptr, &pairs_alloc, &pairs_size, &result );
00246     if( iBase_SUCCESS != result )
00247     {
00248         printf( "Couldn't find relation pair when querying geom.\n" );
00249         return 0;
00250     }
00251     if( pairs_size != 1 || tmp_pair != *pair )
00252     {
00253         printf( "Unexpected relation pairs returned when querying geom.\n" );
00254         return 0;
00255     }
00256 
00257     iRel_findPairs( assoc, mesh, &pair_ptr, &pairs_alloc, &pairs_size, &result );
00258     if( iBase_SUCCESS != result )
00259     {
00260         printf( "Couldn't find relation pair when querying mesh.\n" );
00261         return 0;
00262     }
00263     if( pairs_size != 1 || tmp_pair != *pair )
00264     {
00265         printf( "Unexpected relation pairs returned when querying mesh.\n" );
00266         return 0;
00267     }
00268 
00269     return 1;
00270 }
00271 
00272 /*!
00273   @test
00274   TSTTLasso relate geom and mesh Test
00275   @li Check relation between geom and mesh
00276 */
00277 int relate_geom_mesh_test( iRel_Instance assoc, FBiGeom_Instance geom, iMesh_Instance mesh, iRel_PairHandle pair )
00278 {
00279     /* relate geometry entities with coresponding mesh entity sets */
00280     iBase_EntityHandle* gentities = NULL;
00281     int gentities_size = 0, gentities_alloc = 0;
00282     int result;
00283 
00284     iBase_EntitySetHandle* mentity_handles = NULL;
00285     int mentity_handles_size = 0, mentity_handles_alloc = 0;
00286 
00287     const char* dim_tag_name = "GEOM_DIMENSION";
00288     iBase_TagHandle dim_tag_mesh;
00289 
00290     iBase_EntitySetHandle* mentities_vec;
00291     int mentities_vec_size;
00292     int i;
00293 
00294     iBase_EntitySetHandle* out_mentities = NULL;
00295     int out_mentities_size = 0, out_mentities_alloc = 0;
00296 
00297     iBase_EntitySetHandle* out_mentities2 = NULL;
00298     int out_mentities2_size = 0, out_mentities2_alloc = 0;
00299 
00300     iBase_EntityHandle* out_gentities = NULL;
00301     int out_gentities_size = 0, out_gentities_alloc = 0;
00302 
00303     FBiGeom_getEntities( geom, NULL, iBase_VERTEX, &gentities, &gentities_alloc, &gentities_size, &result );
00304     if( iBase_SUCCESS != result )
00305     {
00306         printf( "Failed to get gentities by type in relate_geom_mesh_test.\n" );
00307         return 0;
00308     }
00309 
00310     iRel_inferEntArrRelations( assoc, pair, gentities, gentities_size, 0, &result );
00311     if( iBase_SUCCESS != result )
00312     {
00313         printf( "Failed to relate geom entities in relate_geom_mesh_test.\n" );
00314         return 0;
00315     }
00316 
00317     /* relate coresponding mesh entity sets for geometry entities */
00318     /* get 1-dimensional mesh entitysets */
00319 
00320     iMesh_getEntSets( mesh, NULL, 1, &mentity_handles, &mentity_handles_alloc, &mentity_handles_size, &result );
00321     if( iBase_SUCCESS != result )
00322     {
00323         printf( "Problem to get all entity sets.\n" );
00324         return 0;
00325     }
00326 
00327     /* get geom dimension tags for mesh entitysets */
00328     iMesh_createTag( mesh, dim_tag_name, 1, iBase_INTEGER, &dim_tag_mesh, &result, 15 );
00329     if( iBase_SUCCESS != result && result != iBase_TAG_ALREADY_EXISTS )
00330     {
00331         printf( "Couldn't create geom dim tag for mesh entities.\n" );
00332         return 0;
00333     }
00334 
00335     /* get 1-dimensional mesh entitysets */
00336     mentities_vec      = (iBase_EntitySetHandle*)malloc( mentity_handles_size * sizeof( iBase_EntitySetHandle ) );
00337     mentities_vec_size = 0;
00338 
00339     for( i = 0; i < mentity_handles_size; i++ )
00340     {
00341         int dim;
00342         iMesh_getEntSetIntData( mesh, mentity_handles[i], dim_tag_mesh, &dim, &result );
00343         if( iBase_SUCCESS != result ) continue;
00344 
00345         if( dim == 1 ) mentities_vec[mentities_vec_size++] = mentity_handles[i];
00346     }
00347 
00348     iRel_inferSetArrRelations( assoc, pair, mentities_vec, mentities_vec_size, 1, &result );
00349     if( iBase_SUCCESS != result )
00350     {
00351         printf( "Failed to relate mesh entities in relate_geom_mesh_test.\n" );
00352         return 0;
00353     }
00354 
00355     /* relate all geometry and mesh entities */
00356     iRel_inferAllRelations( assoc, pair, &result );
00357     if( iBase_SUCCESS != result )
00358     {
00359         printf( "Failed to relate all geom and mesh entities in relate_geom_mesh_test.\n" );
00360         return 0;
00361     }
00362 
00363     /* reset geom entities list and get all geom entities (prev
00364        only vertices) */
00365     free( gentities );
00366     gentities       = NULL;
00367     gentities_alloc = 0;
00368     FBiGeom_getEntities( geom, NULL, iBase_ALL_TYPES, &gentities, &gentities_alloc, &gentities_size, &result );
00369     if( iBase_SUCCESS != result )
00370     {
00371         printf( "Failed to get gentities by type in relate_geom_mesh_test.\n" );
00372         return 0;
00373     }
00374 
00375     /* get related mesh entity sets for geometry entities */
00376     iRel_getEntArrSetArrRelation( assoc, pair, gentities, gentities_size, 0, &out_mentities, &out_mentities_alloc,
00377                                   &out_mentities_size, &result );
00378     if( iBase_SUCCESS != result )
00379     {
00380         printf( "Failed to get geom entities in relate_geom_mesh_test.\n" );
00381         return 0;
00382     }
00383 
00384     if( out_mentities_size != gentities_size )
00385     {
00386         printf( "Number of input geom entities and output mesh entity sets should be same\n" );
00387         return 0;
00388     }
00389 
00390     /* now try deleting this relation */
00391     iRel_rmvEntArrRelation( assoc, pair, gentities, gentities_size, 0, &result );
00392     if( iBase_SUCCESS != result )
00393     {
00394         printf( "Failed to remove relation in relate_geom_mesh_test.\n" );
00395         return 0;
00396     }
00397     iRel_getEntArrSetArrRelation( assoc, pair, gentities, gentities_size, 0, &out_mentities2, &out_mentities2_alloc,
00398                                   &out_mentities2_size, &result );
00399     if( iBase_SUCCESS == result )
00400     {
00401         printf( "Shouldn't have gotten mesh sets in relate_geom_mesh_test.\n" );
00402         return 0;
00403     }
00404 
00405     /* restore the relation, since we need it later */
00406     iRel_setEntArrSetArrRelation( assoc, pair, gentities, gentities_size, out_mentities, out_mentities_size, &result );
00407     if( iBase_SUCCESS != result )
00408     {
00409         printf( "Failed to restore relation in relate_geom_mesh_test.\n" );
00410         return 0;
00411     }
00412 
00413     /* get related geometry entities for mesh entity sets */
00414     iRel_getSetArrEntArrRelation( assoc, pair, out_mentities, out_mentities_size, 1, &out_gentities,
00415                                   &out_gentities_alloc, &out_gentities_size, &result );
00416     if( iBase_SUCCESS != result )
00417     {
00418         printf( "Failed to get mesh entities in relate_geom_mesh_test.\n" );
00419         return 0;
00420     }
00421 
00422     if( out_mentities_size != out_gentities_size )
00423     {
00424         printf( "Number of input mesh entity sets and output geom entities should be same\n" );
00425         return 0;
00426     }
00427     free( mentity_handles );
00428     mentity_handles = NULL;
00429     free( gentities );
00430     gentities = NULL;
00431     free( mentity_handles );
00432     mentity_handles = NULL;
00433     free( out_mentities );
00434     out_mentities = NULL;
00435     free( mentities_vec );
00436     mentities_vec = NULL;
00437     free( out_gentities );
00438     out_gentities = NULL;
00439     return 1;
00440 }
00441 
00442 /*!
00443   @test
00444   TSTTAssoc move to test
00445   @li Move meshes onto the given geometry
00446 */
00447 int query_relations_test( iRel_Instance assoc, FBiGeom_Instance geom, iMesh_Instance mesh, iRel_PairHandle pair )
00448 {
00449     /* get all the geom entities, and find relation to some mesh entity */
00450     iBase_EntityHandle* gentities = NULL;
00451     int gentities_size = 0, gentities_alloc = 0;
00452     int result;
00453 
00454     iBase_EntitySetHandle* out_mentities = NULL;
00455     int out_mentities_size, out_mentities_alloc = 0;
00456 
00457     char descr[120];
00458     int i;
00459     int is_list;
00460 
00461     iBase_EntityHandle* out_gentities = NULL;
00462     int out_gentities_size, out_gentities_alloc = 0;
00463 
00464     FBiGeom_getEntities( geom, NULL, iBase_ALL_TYPES, &gentities, &gentities_alloc, &gentities_size, &result );
00465     if( iBase_SUCCESS != result )
00466     {
00467         printf( "Problem getting all geom entities.\n" );
00468         return 0;
00469     }
00470 
00471     iRel_getEntArrSetArrRelation( assoc, pair, gentities, gentities_size, 0, &out_mentities, &out_mentities_alloc,
00472                                   &out_mentities_size, &result );
00473     /* might not all be */
00474     if( iBase_SUCCESS != result )
00475     {
00476         printf( "Failed to get mesh entities related to geom entities in query_relations_test.\n" );
00477 
00478         iRel_getDescription( assoc, descr, sizeof( descr ) - 1 );
00479         printf( "Entities missing relations: %s\n", descr );
00480 
00481         for( i = 0; i < gentities_size; i++ )
00482         {
00483             print_geom_info( geom, gentities[i] );
00484         }
00485 
00486         return 0;
00487     }
00488 
00489     /* check that they're all non-null */
00490     if( out_mentities_size != gentities_size )
00491     {
00492         printf( "Number of mesh & related geom entities don't match.\n" );
00493         return 0;
00494     }
00495 
00496     /* check to make sure they're mesh sets; how to do that? */
00497     for( i = 0; i < out_mentities_size; i++ )
00498     {
00499         iMesh_isList( mesh, (iBase_EntitySetHandle)out_mentities[i], &is_list, &result );
00500         if( iBase_SUCCESS != result )
00501         {
00502             printf( "Entity set returned from classification wasn't valid.\n" );
00503             return 0;
00504         }
00505     }
00506 
00507     /* now turn around and check classification of those mesh entities */
00508     iRel_getSetArrEntArrRelation( assoc, pair, out_mentities, out_mentities_size, 1, &out_gentities,
00509                                   &out_gentities_alloc, &out_gentities_size, &result );
00510     if( iBase_SUCCESS != result )
00511     {
00512         printf( "Failed to get geom entities related to mesh entities in query_relations_test.\n" );
00513         return 0;
00514     }
00515 
00516     /* check that they're all non-null */
00517     if( out_mentities_size != out_gentities_size )
00518     {
00519         printf( "Number of geom & related mesh entities don't match.\n" );
00520         return 0;
00521     }
00522 
00523     free( gentities );
00524     gentities = NULL;
00525     free( out_mentities );
00526     out_mentities = NULL;
00527     free( out_gentities );
00528     out_gentities = NULL;
00529     /* ok, we're done */
00530     return 1;
00531 }
00532 
00533 int main( int argc, char* argv[] )
00534 {
00535     /* Check command line arg */
00536     const char* geom_filename = DEFAULT_INPUT_FILE;
00537     const char* mesh_filename = DEFAULT_INPUT_FILE1;
00538 
00539     int result;
00540     int number_tests                 = 0;
00541     int number_tests_successful      = 0;
00542     int number_tests_not_implemented = 0;
00543     int number_tests_failed          = 0;
00544 
00545     FBiGeom_Instance geom;
00546     iMesh_Instance mesh;
00547     iRel_Instance assoc;
00548     iRel_PairHandle pair;
00549 
00550     if( argc == 2 && !strcmp( argv[1], "-h" ) )
00551     {
00552         printf( "Usage: %s <geom_filename> <mesh_filename>\n", argv[0] );
00553         return 1;
00554     }
00555     else if( argc == 2 )
00556     {
00557         geom_filename = argv[1];
00558         mesh_filename = argv[1];
00559     }
00560     else if( argc == 3 )
00561     {
00562         geom_filename = argv[1];
00563         mesh_filename = argv[2];
00564     }
00565 
00566     /* initialize the Geometry */
00567     FBiGeom_newGeom( 0, &geom, &result, 0 );
00568 
00569     /* initialize the Mesh */
00570     iMesh_newMesh( 0, &mesh, &result, 0 );
00571 
00572     /* initialize the Associate */
00573     iRel_create( 0, &assoc, &result, 0 );
00574 
00575     /* Print out Header information */
00576     printf( "\n\niRel TEST PROGRAM:\n\n" );
00577 
00578     /* load_geom_mesh test */
00579     printf( "   load_geom_mesh: " );
00580     result = load_geom_mesh_test( geom_filename, mesh_filename, geom, mesh );
00581     handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
00582     number_tests++;
00583     printf( "\n" );
00584 
00585     /* create_relation test */
00586     printf( "   create_relation: " );
00587     result = create_relation_test( assoc, geom, mesh, &pair );
00588     handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
00589     number_tests++;
00590     printf( "\n" );
00591 
00592     /* relate_geom_mesh test */
00593     printf( "   relate_geom_mesh: " );
00594     result = relate_geom_mesh_test( assoc, geom, mesh, pair );
00595     handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
00596     number_tests++;
00597     printf( "\n" );
00598 
00599     /* query_relations test */
00600     printf( "   query_relations: " );
00601     result = query_relations_test( assoc, geom, mesh, pair );
00602     handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
00603     number_tests++;
00604     printf( "\n" );
00605 
00606     /* summary */
00607 
00608     printf( "\niRel TEST SUMMARY: \n" );
00609     printf( "   Number Tests:           %d\n", number_tests );
00610     printf( "   Number Successful:      %d\n", number_tests_successful );
00611     printf( "   Number Not Implemented: %d\n", number_tests_not_implemented );
00612     printf( "   Number Failed:          %d\n", number_tests_failed );
00613     printf( "\n\n" );
00614 
00615     iRel_destroy( assoc, &result );
00616     iMesh_dtor( mesh, &result );
00617     FBiGeom_dtor( geom, &result );
00618 
00619     return number_tests_failed != 0;
00620 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines