|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
#include <cstdio>#include <cstring>#include <cstdlib>#include "iMesh.h"#include "iMesh_extensions.h"#include "moab/Types.hpp"#include "TestUtil.hpp"
Include dependency graph for testc_cbind.cpp:Go to the source code of this file.
| #define ASSERT | ( | COND | ) |
assert_pass = true; \ if( !( COND ) ) \ { \ PRINT_ASSERT_FAILURE( #COND, __FILE__, __LINE__ ); \ assert_pass = false; \ }
Definition at line 82 of file testc_cbind.cpp.
Referenced by entity_connectivity_test().
| #define CHK | ( | err | ) |
if( (err) != iBase_SUCCESS ) do \ { \ printf( "%s:%d ITAPS error %d\n", __FILE__, __LINE__, err ); \ return 0; \ } while( 0 )
Definition at line 96 of file testc_cbind.cpp.
Referenced by array_allocation(), ordered_set_regression(), test_iterator(), and test_iterator_common().
| #define DEFAULT_INPUT_FILE STRINGIFY( DEFAULT_TEST_FILE ) |
Definition at line 78 of file testc_cbind.cpp.
Referenced by main().
| #define DEFAULT_TEST_FILE brick.vtk |
Definition at line 71 of file testc_cbind.cpp.
| #define FALSE 0 |
Definition at line 68 of file testc_cbind.cpp.
Referenced by check_esets(), entity_connectivity_test(), entity_sets_subtest(), entityset_double_tag_test(), entityset_int_tag_test(), entityset_struct_tag_test(), entityset_tag_delete_test(), entityset_tag_test(), load_mesh_test(), mesh_double_tag_test(), mesh_int_tag_test(), mesh_struct_tag_test(), mesh_tag_delete_test(), tag_info_test(), topology_adjacency_test(), topology_dimension_test(), vertex_coordinates_test(), vertex_double_tag_test(), vertex_int_tag_test(), vertex_struct_tag_test(), vertex_tag_delete_test(), and vertex_tag_test().
| #define TEST_ERROR_CODE | ( | A, | |
| B | |||
| ) |
if( iBase_ERROR_MAP[( A )] != ( B ) ) \ { \ printf( "ERROR: Invalid mapping for MOAB error code %s\n", #A ); \ printf( " Expected %d, actual is %d\n", (int)iBase_ERROR_MAP[( A )], (int)( B ) ); \ return FALSE; \ }
Definition at line 143 of file testc_cbind.cpp.
Referenced by error_code_test().
| #define TRUE 1 |
Definition at line 69 of file testc_cbind.cpp.
Referenced by check_esets(), moab::WriteCCMIO::create_ccmio_structure(), entity_connectivity_test(), entity_sets_subtest(), entity_sets_test(), entityset_double_tag_test(), entityset_int_tag_test(), entityset_struct_tag_test(), entityset_tag_delete_test(), error_code_test(), load_mesh_test(), mesh_double_tag_test(), mesh_int_tag_test(), mesh_struct_tag_test(), mesh_tag_delete_test(), tag_info_test(), topology_adjacency_test(), topology_dimension_test(), vertex_coordinates_test(), vertex_double_tag_test(), vertex_int_tag_test(), vertex_struct_tag_test(), and vertex_tag_delete_test().
| int all_adjacency_regression | ( | iMesh_Instance | mesh | ) |
Definition at line 2659 of file testc_cbind.cpp.
References iBase_ALL_TYPES, iBase_INTERLEAVED, iBase_NEW, iBase_SUCCESS, iMesh_createEnt, iMesh_createVtxArr, iMesh_dtor, iMesh_getEntAdj, iMesh_LINE_SEGMENT, and iMesh_newMesh.
Referenced by main().
{
int err;
double coords[] = { 0, 0, 0, 1, 1, 1 };
iBase_EntityHandle* verts = NULL;
int verts_alloc = 0, verts_size;
iBase_EntityHandle line;
int status;
iBase_EntityHandle* adj = NULL;
int adj_alloc = 0, adj_size;
iMesh_newMesh( "", &mesh, &err, 0 );
if( iBase_SUCCESS != err ) return 0;
iMesh_createVtxArr( mesh, 2, iBase_INTERLEAVED, coords, 6, &verts, &verts_alloc, &verts_size, &err );
if( iBase_SUCCESS != err ) return 0;
iMesh_createEnt( mesh, iMesh_LINE_SEGMENT, verts, 2, &line, &status, &err );
if( iBase_SUCCESS != err || status != iBase_NEW ) return 0;
iMesh_getEntAdj( mesh, verts[0], iBase_ALL_TYPES, &adj, &adj_alloc, &adj_size, &err );
if( iBase_SUCCESS != err ) return 0;
if( adj_size != 1 || adj[0] != line )
{
printf( "Bad: couldn't find adjacency for vertex\n" );
return 0;
}
free( adj );
adj_alloc = 0;
adj = NULL;
iMesh_getEntAdj( mesh, line, iBase_ALL_TYPES, &adj, &adj_alloc, &adj_size, &err );
if( iBase_SUCCESS != err ) return 0;
if( adj_size != 2 ||
( ( adj[0] != verts[0] || adj[1] != verts[1] ) && ( adj[0] != verts[1] || adj[1] != verts[0] ) ) )
{
printf( "Bad: couldn't find adjacencies for line\n" );
free( adj );
free( verts );
return 0;
}
free( adj );
free( verts );
iMesh_dtor( mesh, &err );
if( iBase_SUCCESS != err ) return 0;
return 1;
}
| int array_allocation | ( | iMesh_Instance | mesh | ) |
Definition at line 2749 of file testc_cbind.cpp.
References CHK, iBase_ALL_TYPES, iBase_BAD_ARRAY_DIMENSION, iBase_BAD_ARRAY_SIZE, iBase_FAILURE, iBase_INTERLEAVED, iBase_SUCCESS, iMesh_ALL_TOPOLOGIES, iMesh_createVtxArr, iMesh_dtor, iMesh_getEntities, iMesh_getRootSet, iMesh_newMesh, and root_set.
Referenced by main().
{
int err;
double coords[] = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3 };
iBase_EntityHandle* verts = NULL;
int verts_alloc = 0, verts_size;
iBase_EntityHandle* ents;
int ents_alloc, ents_size;
iMesh_newMesh( "", &mesh, &err, 0 );
if( iBase_SUCCESS != err ) return 0;
iMesh_getRootSet( mesh, &root_set, &err );
if( iBase_SUCCESS != err )
{
printf( "Failed to return a root set.\n" );
return 0;
}
iMesh_createVtxArr( mesh, 4, iBase_INTERLEAVED, coords, 12, &verts, &verts_alloc, &verts_size, &err );
if( iBase_SUCCESS != err ) return 0;
free( verts );
/* test for proper allocation when array pointer passed in null but alloc'd size not */
ents_alloc = 3;
ents = NULL;
iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &ents, &ents_alloc, &ents_size, &err );
CHK( err );
free( ents );
/* test for proper allocation when array pointer passed in non-null but alloc'd size 0 */
ents_alloc = 0;
iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &ents, &ents_alloc, &ents_size, &err );
CHK( err );
free( ents );
/* test for failure when passed in alloc'd size is smaller than it should be */
ents_alloc -= 1;
iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &ents, &ents_alloc, &ents_size, &err );
if( iBase_BAD_ARRAY_SIZE != err && iBase_BAD_ARRAY_DIMENSION != err )
{
err = iBase_FAILURE;
CHK( err );
}
iMesh_dtor( mesh, &err );
CHK( err );
return 1;
}
| int check_esets | ( | iMesh_Instance | mesh, |
| const int | num_sets | ||
| ) |
Definition at line 1623 of file testc_cbind.cpp.
References FALSE, iBase_SUCCESS, iMesh_getNumEntSets, root_set, and TRUE.
Referenced by entity_sets_subtest(), and mb_mesh_sets_test().
{
int entity_sets_size;
int result;
iMesh_getNumEntSets( mesh, root_set, 1, &entity_sets_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem to get all entity sets in mesh.\n" );
return FALSE;
}
if( entity_sets_size != num_sets )
{
printf( "the number of entity sets in whole mesh should be %d"
", actual number is %d.\n",
num_sets, entity_sets_size );
return FALSE;
}
return TRUE;
}
| int compare_array_iter | ( | const char * | info, |
| iMesh_Instance | mesh, | ||
| iBase_EntitySetHandle | set, | ||
| iBase_EntityHandle * | contents, | ||
| int | contents_size, | ||
| int | array_size, | ||
| enum iBase_EntityType | type, | ||
| enum iMesh_EntityTopology | topo | ||
| ) |
Definition at line 2893 of file testc_cbind.cpp.
References iBase_FAILURE, iBase_SUCCESS, iMesh_endEntArrIter, iMesh_getNextEntArrIter, iMesh_initEntArrIter, and iMesh_resetEntArrIter.
Referenced by test_iterator_common().
{
iBase_EntityArrIterator iter = 0;
int i, j, twice, has_data, result = iBase_SUCCESS, result2;
iBase_EntityHandle* values;
int values_size, values_alloc = array_size;
values = (iBase_EntityHandle*)malloc( array_size * sizeof( iBase_EntityHandle ) );
iMesh_initEntArrIter( mesh, set, type, topo, array_size, 0, &iter, &result );
if( iBase_SUCCESS != result )
{
printf( "%s:%d: Error %d initializing %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result,
info, (int)type, (int)topo );
free( values );
return result;
}
for( twice = 0; twice < 2; ++twice )
{
i = 0;
while( i < contents_size )
{
iMesh_getNextEntArrIter( mesh, iter, &values, &values_alloc, &values_size, &has_data, &result );
if( iBase_SUCCESS != result )
{
printf( "%s:%d: Error %d stepping %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result,
info, (int)type, (int)topo );
goto end_arr_iter;
}
if( !has_data || !values_size )
{
printf( "%s:%d: %s array iterator for type %d/topo %d ended prematurely at %d of %d\n", __FILE__,
__LINE__, info, (int)type, (int)topo, i, contents_size );
result = iBase_FAILURE;
goto end_arr_iter;
}
if( i + values_size > contents_size )
{
printf( "%s:%d: %s array iterator for type %d/topo %d returned more than %d handles\n", __FILE__,
__LINE__, info, (int)type, (int)topo, contents_size );
result = iBase_FAILURE;
goto end_arr_iter;
}
if( contents_size - i >= array_size && values_size < array_size )
{
printf( "%s:%d: %s array iterator for type %d/topo %d returned fewer than %d handles\n", __FILE__,
__LINE__, info, (int)type, (int)topo, array_size );
result = iBase_FAILURE;
goto end_arr_iter;
}
for( j = 0; j < values_size; ++j, ++i )
{
if( values[j] != contents[i] )
{
printf( "%s:%d: %s array iterator for type %d/topo %d returned incorrect value "
"at %d of %d\n",
__FILE__, __LINE__, info, (int)type, (int)topo, i, contents_size );
result = iBase_FAILURE;
goto end_arr_iter;
}
}
}
iMesh_getNextEntArrIter( mesh, iter, &values, &values_alloc, &values_size, &has_data, &result );
if( iBase_SUCCESS != result )
{
printf( "%s:%d: Error %d stepping %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result,
info, (int)type, (int)topo );
goto end_arr_iter;
}
if( has_data || values_size )
{
printf( "%s:%d: %s array iterator for type %d/topo %d did not end after %d values\n", __FILE__, __LINE__,
info, (int)type, (int)topo, contents_size );
result = iBase_FAILURE;
goto end_arr_iter;
}
iMesh_resetEntArrIter( mesh, iter, &result );
if( iBase_SUCCESS != result )
{
printf( "%s:%d: Error %d resetting %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result,
info, (int)type, (int)topo );
result = iBase_FAILURE;
goto end_arr_iter;
}
}
end_arr_iter:
free( values );
iMesh_endEntArrIter( mesh, iter, &result2 );
if( iBase_SUCCESS != result2 )
{
printf( "%s:%d: Error %d releasing %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
(int)type, (int)topo );
if( iBase_SUCCESS == result ) result = result2;
}
return result;
}
| int compare_single_iter | ( | const char * | info, |
| iMesh_Instance | mesh, | ||
| iBase_EntitySetHandle | set, | ||
| iBase_EntityHandle * | contents, | ||
| int | contents_size, | ||
| enum iBase_EntityType | type, | ||
| enum iMesh_EntityTopology | topo | ||
| ) |
Definition at line 2806 of file testc_cbind.cpp.
References iBase_FAILURE, iBase_SUCCESS, iMesh_endEntIter, iMesh_getNextEntIter, iMesh_initEntIter, and iMesh_resetEntIter.
Referenced by test_iterator_common().
{
iBase_EntityIterator iter = 0;
int i, twice, has_data, result = iBase_SUCCESS, result2;
iBase_EntityHandle value;
iMesh_initEntIter( mesh, set, type, topo, 0, &iter, &result );
if( iBase_SUCCESS != result )
{
printf( "%s:%d: Error %d initializing %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
(int)type, (int)topo );
return result;
}
for( twice = 0; twice < 2; ++twice )
{
for( i = 0; i < contents_size; ++i )
{
iMesh_getNextEntIter( mesh, iter, &value, &has_data, &result );
if( iBase_SUCCESS != result )
{
printf( "%s:%d: Error %d stepping %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
(int)type, (int)topo );
goto end_single_iter;
}
if( !has_data )
{
printf( "%s:%d: %s iterator for type %d/topo %d ended prematurely at %d of %d\n", __FILE__, __LINE__,
info, (int)type, (int)topo, i, contents_size );
result = iBase_FAILURE;
goto end_single_iter;
}
if( value != contents[i] )
{
printf( "%s:%d: %s iterator for type %d/topo %d returned incorrect value at %d of %d\n", __FILE__,
__LINE__, info, (int)type, (int)topo, i, contents_size );
result = iBase_FAILURE;
goto end_single_iter;
}
}
iMesh_getNextEntIter( mesh, iter, &value, &has_data, &result );
if( iBase_SUCCESS != result )
{
printf( "%s:%d: Error %d stepping %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
(int)type, (int)topo );
goto end_single_iter;
}
if( has_data )
{
printf( "%s:%d: %s iterator for type %d/topo %d did not end after %d values\n", __FILE__, __LINE__, info,
(int)type, (int)topo, contents_size );
result = iBase_FAILURE;
goto end_single_iter;
}
iMesh_resetEntIter( mesh, iter, &result );
if( iBase_SUCCESS != result )
{
printf( "%s:%d: Error %d resetting %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
(int)type, (int)topo );
result = iBase_FAILURE;
goto end_single_iter;
}
}
end_single_iter:
iMesh_endEntIter( mesh, iter, &result2 );
if( iBase_SUCCESS != result2 )
{
printf( "%s:%d: Error %d releasing %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
(int)type, (int)topo );
if( iBase_SUCCESS == result ) result = result2;
}
return result;
}
| int entity_connectivity_test | ( | iMesh_Instance | mesh | ) |
Definition at line 514 of file testc_cbind.cpp.
References ASSERT, assert_pass, entities, FALSE, iBase_ALL_TYPES, iBase_EDGE, iBase_SUCCESS, iBase_VERTEX, iMesh_ALL_TOPOLOGIES, iMesh_getAdjEntIndices, iMesh_getEntAdj, iMesh_getEntities, qsort_comp_handles(), root_set, size, and TRUE.
Referenced by main().
{
int type, result;
int *offsets, offsets_alloc, offsets_size;
int *indices, indices_alloc, indices_size;
iBase_EntityHandle *entities, *adj_ents, *entities2, *sorted;
int entities_alloc, entities_size, adj_ents_alloc, adj_ents_size;
int entities2_alloc, entities2_size;
iBase_EntityHandle adj_ents2[27], *adj_ents2_ptr = adj_ents2;
int adj_ents2_alloc = 27, adj_ents2_size, i, size;
for( type = iBase_EDGE; type < iBase_ALL_TYPES; type++ )
{
entities = NULL;
entities_alloc = 0;
adj_ents = NULL;
adj_ents_alloc = 0;
indices = NULL;
indices_alloc = 0;
offsets = NULL;
offsets_alloc = 0;
iMesh_getAdjEntIndices( mesh, root_set, type, iMesh_ALL_TOPOLOGIES, iBase_VERTEX, &entities, &entities_alloc,
&entities_size, &adj_ents, &adj_ents_alloc, &adj_ents_size, &indices, &indices_alloc,
&indices_size, &offsets, &offsets_alloc, &offsets_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get indices of vertices in connectivity_test, type=%d.\n", type );
return FALSE;
}
if( entities_alloc != entities_size )
{
printf( "Number of entities didn't agree with array size in connectivity_test.\n" );
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
if( offsets_alloc != offsets_size )
{
printf( "Number of offsets didn't agree with array size in connectivity_test.\n" );
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
if( indices_alloc != indices_size )
{
printf( "Number of indices didn't agree with array size in connectivity_test.\n" );
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
if( adj_ents_alloc != adj_ents_size )
{
printf( "Number of adjacent entities didn't agree with array size in "
"connectivity_test.\n" );
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
if( offsets_size != entities_size + 1 )
{
printf( "Invalid/inconsistent offset size from iMesh_getAdjEntIndices.\n" );
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
/* check that results are valid */
for( i = 0; i < entities_size; ++i )
{
ASSERT( offsets[i] < offsets[i + 1] && offsets[i] < indices_size );
if( !assert_pass )
{
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
}
for( i = 0; i < indices_size; ++i )
{
ASSERT( indices[i] >= 0 && indices[i] < adj_ents_size );
if( !assert_pass )
{
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
}
/* compare initial entity list against result of iMesh_getEntities */
entities2 = NULL;
entities2_alloc = 0;
iMesh_getEntities( mesh, root_set, type, iMesh_ALL_TOPOLOGIES, &entities2, &entities2_alloc, &entities2_size,
&result );
ASSERT( iBase_SUCCESS == result );
if( !assert_pass )
{
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
size = sizeof( iBase_EntityHandle ) * entities_size;
sorted = (iBase_EntityHandle*)malloc( size );
memcpy( sorted, entities, size );
qsort( sorted, entities_size, sizeof( iBase_EntityHandle ), &qsort_comp_handles );
qsort( entities2, entities2_size, sizeof( iBase_EntityHandle ), &qsort_comp_handles );
ASSERT( entities_size == entities2_size && !memcmp( sorted, entities2, size ) );
if( !assert_pass )
{
free( entities );
free( adj_ents );
free( indices );
free( offsets );
free( entities2 );
free( sorted );
return FALSE;
}
free( entities2 );
free( sorted );
/* compare results against output of iMesh_getEntAdj */
for( i = 0; i < entities_size; ++i )
{
iMesh_getEntAdj( mesh, entities[i], iBase_VERTEX, &adj_ents2_ptr, &adj_ents2_alloc, &adj_ents2_size,
&result );
ASSERT( iBase_SUCCESS == result );
if( !assert_pass )
{
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
ASSERT( adj_ents2_ptr == adj_ents2 ); /* shouldn't change */
if( !assert_pass )
{
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
ASSERT( adj_ents2_alloc == 27 ); /* shouldn't change */
if( !assert_pass )
{
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
/* compare results */
size = offsets[i + 1] - offsets[i];
ASSERT( size == adj_ents2_size );
while( --size >= 0 )
{
ASSERT( adj_ents2[size] == adj_ents[indices[offsets[i] + size]] );
if( !assert_pass )
{
free( entities );
free( adj_ents );
free( indices );
free( offsets );
return FALSE;
}
}
}
free( entities );
free( adj_ents );
free( indices );
free( offsets );
/*
offsets = NULL;
offsets_alloc = 0;
entities = NULL;
entities_alloc = 0;
iMesh_getAdjEntities(mesh, root_set, type,
iMesh_ALL_TOPOLOGIES, iBase_VERTEX,
&entities, &entities_alloc, &entities_size,
&offsets, &offsets_alloc, &offsets_size,
&result);
if (iBase_SUCCESS != result) {
printf("Failed to get indices of adjacent entity vertices in connectivity_test.\n");
return FALSE;
}
if (entities_alloc != entities_size ||
offsets_alloc != offsets_size) {
printf("Number of elements didn't agree with array size for an array in
connectivity_test.\n"); return FALSE;
}
free(offsets);
free(entities);
*/
}
return TRUE;
}
| int entity_sets_subtest | ( | iMesh_Instance | mesh, |
| int | is_list, | ||
| int | |||
| ) |
Definition at line 754 of file testc_cbind.cpp.
References check_esets(), entities, FALSE, iBase_ALL_TYPES, iBase_EDGE, iBase_FACE, iBase_REGION, iBase_SUCCESS, iBase_VERTEX, iMesh_addEntArrToSet, iMesh_addEntSet, iMesh_addPrntChld, iMesh_ALL_TOPOLOGIES, iMesh_createEntSet, iMesh_destroyEntSet, iMesh_getEntArrAdj, iMesh_getEntArrType, iMesh_getEntities, iMesh_getEntSets, iMesh_getNumChld, iMesh_getNumEntSets, iMesh_getNumOfType, iMesh_getPrnts, iMesh_HEXAHEDRON, iMesh_intersect, iMesh_isChildOf, iMesh_rmvEntArrFromSet, iMesh_subtract, iMesh_unite, root_set, and TRUE.
Referenced by entity_sets_test().
{
int i, num_type = iBase_ALL_TYPES - iBase_VERTEX;
// int num_all_entities_super = 0;
iBase_EntitySetHandle es_array[iBase_ALL_TYPES - iBase_VERTEX];
int number_array[iBase_ALL_TYPES - iBase_VERTEX];
int ent_type = iBase_VERTEX;
iBase_EntityHandle* entities = NULL;
int entities_alloc = 0, entities_size;
iBase_EntitySetHandle parent_child, super_set = NULL;
iBase_EntitySetHandle temp_es1, temp_es2, temp_es3;
iBase_EntityHandle *edges = NULL, *faces = NULL, *temp_entities1 = NULL, *temp_entities2 = NULL;
int edges_alloc = 0, faces_alloc = 0, temp_entities1_alloc = 0, temp_entities2_alloc = 0;
int edges_size, faces_size, temp_entities1_size, temp_entities2_size;
int* types = NULL;
int types_alloc = 0, types_size;
int num_rest, num_regions;
iBase_EntityHandle* regions = NULL;
int regions_alloc = 0, regions_size;
iBase_EntitySetHandle* parents = NULL;
int parents_alloc = 0, parents_size, temp_numb, is_child;
iBase_EntitySetHandle* es_array1 = NULL;
int es_array1_alloc = 0, es_array1_size, num_super;
iBase_EntityHandle* all_entities = NULL;
int all_entities_alloc = 0, all_entities_size, k, l;
iBase_EntityHandle* adj_faces = NULL;
int adj_faces_alloc = 0, adj_faces_size;
int* face_offsets = NULL;
int face_offsets_alloc = 0, face_offsets_size;
iBase_EntityHandle* hexes = NULL;
int hexes_alloc = 0, hexes_size;
iBase_EntitySetHandle hex_set;
/* get the number of whole mesh */
int n_whole_mesh = 0;
int result;
iMesh_getNumEntSets( mesh, root_set, 1, &n_whole_mesh, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem to get the number of all entity sets in whole mesh.\n" );
return FALSE;
}
/* add entities to entitysets by type */
for( ; ent_type < num_type; ent_type++ )
{
/* initialize the entityset */
iMesh_createEntSet( mesh, is_list, &es_array[ent_type], &result );
if( iBase_SUCCESS != result )
{
printf( "Problem creating entityset.\n" );
return FALSE;
}
/* get entities by type in total "mesh" */
entities = NULL;
entities_alloc = 0;
iMesh_getEntities( mesh, root_set, ent_type, iMesh_ALL_TOPOLOGIES, &entities, &entities_alloc, &entities_size,
&result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get entities by type in entity_sets_test.\n" );
return FALSE;
}
if( entities_alloc != entities_size )
{
printf( "Number of entities didn't agree with array size in entity_sets_subtest.\n" );
free( entities );
return FALSE;
}
/* add entities into entity set */
if( 0 != entities_size )
{
iMesh_addEntArrToSet( mesh, entities, entities_size, es_array[ent_type], &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to add entities in entity_sets_test.\n" );
free( entities );
return FALSE;
}
}
/* Check to make sure entity set really has correct number of entities in it */
iMesh_getNumOfType( mesh, es_array[ent_type], ent_type, number_array + ent_type, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get number of entities by type in entity_sets_test.\n" );
free( entities );
return FALSE;
}
/* compare the number of entities by type */
if( number_array[ent_type] != entities_size )
{
printf( "Number of entities by type is not correct\n" );
free( entities );
return FALSE;
}
/* add to number of all entities in super set */
// num_all_entities_super += entities_size;
free( entities );
}
if( !check_esets( mesh, n_whole_mesh + num_type ) ) return FALSE;
/* make a super set having all entitysets */
super_set = NULL;
iMesh_createEntSet( mesh, is_list, &super_set, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to create a super set in entity_sets_test.\n" );
return FALSE;
}
for( i = 0; i < num_type; i++ )
{
iMesh_addEntSet( mesh, es_array[i], super_set, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to add a set to a super set in entity_sets_test.\n" );
return FALSE;
}
}
if( !check_esets( mesh, n_whole_mesh + num_type + 1 ) ) return FALSE;
/*----------TEST intEAN OPERATIONS----------------*/
iMesh_createEntSet( mesh, is_list, &temp_es1, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to create a super set in entity_sets_test.\n" );
return FALSE;
}
if( !check_esets( mesh, n_whole_mesh + num_type + 2 ) )
{
return FALSE;
}
/* Subtract */
/* add all EDGEs and FACEs to temp_es1 */
/* get all EDGE entities */
edges = NULL;
edges_alloc = 0;
iMesh_getEntities( mesh, es_array[iBase_EDGE], iBase_EDGE, iMesh_ALL_TOPOLOGIES, &edges, &edges_alloc, &edges_size,
&result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get edge entities in entity_sets_test.\n" );
return FALSE;
}
/* add EDGEs to es1 */
iMesh_addEntArrToSet( mesh, edges, edges_size, temp_es1, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to add edge entities in entity_sets_test.\n" );
free( edges );
return FALSE;
}
/* get all FACE entities */
faces = NULL;
faces_alloc = 0;
iMesh_getEntities( mesh, es_array[iBase_FACE], iBase_FACE, iMesh_ALL_TOPOLOGIES, &faces, &faces_alloc, &faces_size,
&result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get face entities in entity_sets_test.\n" );
free( edges );
return FALSE;
}
/* add FACEs to es1 */
iMesh_addEntArrToSet( mesh, faces, faces_size, temp_es1, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to add face entities in entity_sets_test.\n" );
free( edges );
free( faces );
return FALSE;
}
/* subtract EDGEs */
iMesh_subtract( mesh, temp_es1, es_array[iBase_EDGE], &temp_es2, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to subtract entitysets in entity_sets_test.\n" );
free( edges );
free( faces );
return FALSE;
}
temp_entities1 = NULL;
temp_entities1_alloc = 0;
iMesh_getEntities( mesh, temp_es2, iBase_FACE, iMesh_ALL_TOPOLOGIES, &temp_entities1, &temp_entities1_alloc,
&temp_entities1_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get face entities in entity_sets_test.\n" );
free( edges );
free( faces );
return FALSE;
}
if( faces_size != temp_entities1_size )
{
printf( "not match number of entitysets after subtraction "
"in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
return FALSE;
}
/* check there's nothing but faces in face_es */
types = NULL;
types_alloc = 0;
iMesh_getEntArrType( mesh, temp_entities1, temp_entities1_size, &types, &types_alloc, &types_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get types of entities in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
return FALSE;
}
for( i = 0; i < types_size; i++ )
{
if( types[i] != iBase_FACE )
{
printf( "wrong entity type for face test in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
}
iMesh_destroyEntSet( mesh, temp_es2, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to destroy temp es2.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
if( !check_esets( mesh, n_whole_mesh + num_type + 2 ) )
{
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
/*------------Intersect------------ */
/* clean out the temp_ms1 */
iMesh_rmvEntArrFromSet( mesh, faces, faces_size, temp_es1, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to remove face entities in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
/* check if it is really cleaned out */
iMesh_getNumOfType( mesh, temp_es1, iBase_FACE, &num_rest, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get number of entities by type in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
if( num_rest != 0 )
{
printf( "failed to remove correctly.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
/* add EDGEs to temp es1 */
iMesh_addEntArrToSet( mesh, edges, edges_size, temp_es1, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to add edge entities in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
/* add FACEs to temp es1 */
iMesh_addEntArrToSet( mesh, faces, faces_size, temp_es1, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to add edge entities in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
/* intersect temp_es1 with edges meshset */
/* temp_ms1 entityset is altered */
iMesh_intersect( mesh, temp_es1, es_array[iBase_EDGE], &temp_es2, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to intersect in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
temp_entities2 = NULL;
temp_entities2_alloc = 0;
iMesh_getEntities( mesh, temp_es2, iBase_FACE, iMesh_ALL_TOPOLOGIES, &temp_entities2, &temp_entities2_alloc,
&temp_entities2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get face entities in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( types );
return FALSE;
}
if( temp_entities2_size != 0 )
{
printf( "wrong number of faces.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
return FALSE;
}
iMesh_destroyEntSet( mesh, temp_es2, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to destroy temp es2.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
return FALSE;
}
if( !check_esets( mesh, n_whole_mesh + num_type + 2 ) )
{
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
return FALSE;
}
/*-------------Unite-------------- */
iMesh_createEntSet( mesh, is_list, &temp_es2, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to create a temp entityset in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
return FALSE;
}
/* get all regions */
regions = NULL;
regions_alloc = 0;
iMesh_getEntities( mesh, es_array[iBase_REGION], iBase_REGION, iMesh_ALL_TOPOLOGIES, ®ions, ®ions_alloc,
®ions_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get region entities in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
return FALSE;
}
/* add REGIONs to temp es2 */
iMesh_addEntArrToSet( mesh, regions, regions_size, temp_es2, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to add region entities in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
return FALSE;
}
/* unite temp_es1 and temp_es2 */
iMesh_unite( mesh, temp_es1, temp_es2, &temp_es3, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to unite in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
return FALSE;
}
/* perform the check */
iMesh_getNumOfType( mesh, temp_es3, iBase_REGION, &num_regions, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get number of region entities by type in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
return FALSE;
}
if( num_regions != number_array[iBase_REGION] )
{
printf( "different number of regions in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
return FALSE;
}
if( !check_esets( mesh, n_whole_mesh + num_type + 4 ) )
{
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
return FALSE;
}
/*--------Test parent/child stuff in entiysets----------- */
/* Add 2 meshsets as children to another */
iMesh_createEntSet( mesh, is_list, &parent_child, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem creating entityset in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
return FALSE;
}
iMesh_addPrntChld( mesh, es_array[iBase_VERTEX], parent_child, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem add parent in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
return FALSE;
}
/* check if parent is really added */
parents = NULL;
parents_alloc = 0;
iMesh_getPrnts( mesh, parent_child, 0, &parents, &parents_alloc, &parents_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem getting parents in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
return FALSE;
}
if( parents_size != 1 )
{
printf( "number of parents is not correct in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
return FALSE;
}
/* get the number of child entitysets */
iMesh_getNumChld( mesh, es_array[iBase_VERTEX], 0, &temp_numb, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem getting number of children in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
return FALSE;
}
if( temp_numb != 1 )
{
printf( "number of children is not correct in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
return FALSE;
}
/* parent_child and es_array[iBase_VERTEX] should be related */
is_child = 0;
iMesh_isChildOf( mesh, es_array[iBase_VERTEX], parent_child, &is_child, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem checking relation in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
return FALSE;
}
if( !is_child )
{
printf( "parent_child and es_array[iBase_VERTEX] should be related\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
return FALSE;
}
/* es_array[iBase_FACE] and es_array[iBase_REGION] are not related */
is_child = FALSE;
iMesh_isChildOf( mesh, es_array[iBase_FACE], es_array[iBase_REGION], &is_child, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem checking relation in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
return FALSE;
}
if( is_child )
{
printf( "es_array[iBase_REGION] and es_array[iBase_FACE] should not be related\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
return FALSE;
}
if( !check_esets( mesh, n_whole_mesh + num_type + 5 ) )
{
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
return FALSE;
}
/*--------test modify and query functions----------------------------- */
/* get all entity sets in super set */
es_array1 = NULL;
es_array1_alloc = 0;
iMesh_getEntSets( mesh, super_set, 0, &es_array1, &es_array1_alloc, &es_array1_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem to get entity sets in super set.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
return FALSE;
}
/* get the number of entity sets in super set */
iMesh_getNumEntSets( mesh, super_set, 0, &num_super, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem to get the number of all entity sets in super set.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
return FALSE;
}
/* the number of entity sets in super set should be same */
if( num_super != es_array1_size )
{
printf( "the number of entity sets in super set should be same.\n" );
return FALSE;
}
/* get all entities in super set */
all_entities = NULL;
all_entities_alloc = 0;
iMesh_getEntities( mesh, super_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &all_entities, &all_entities_alloc,
&all_entities_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem to get all entities in super set.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
return FALSE;
}
/* compare the number of all entities in super set */
/* NOTE: TEST COMMENTED OUT UNTIL RESOLUTION OF WHETHER GETENTITIES */
/* SHOULD GET A NUM_HOPS ARGUMENT */
/* if (num_all_entities_super != all_entities_size) { */
/* printf("number of all entities in super set should be same.\n"); */
/* return FALSE; */
/* } */
/* test add, remove and get all entity sets using super set */
/* check GetAllEntitySets works recursively and dosen't return */
/* multi sets */
for( k = 0; k < num_super; k++ )
{
/* add entity sets of super set to each entity set of super set */
/* make multiple child super sets */
iBase_EntitySetHandle es_k = es_array1[k];
for( l = 0; l < es_array1_size; l++ )
{
iMesh_addEntSet( mesh, es_array1[l], es_k, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem to add entity set to entityset.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
free( all_entities );
return FALSE;
}
}
/* add super set to each entity set */
iMesh_addEntSet( mesh, super_set, es_k, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem to add super set to entitysets.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
free( all_entities );
return FALSE;
}
/* add one entity sets multiple times */
for( l = 0; l < 3; l++ )
{
iMesh_addEntSet( mesh, temp_es1, es_k, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem to add temp set to entitysets.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
free( all_entities );
return FALSE;
}
}
}
/* get all hexes and get faces of that hexes */
hexes = NULL;
hexes_alloc = 0;
iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_HEXAHEDRON, &hexes, &hexes_alloc, &hexes_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get hexes in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
free( all_entities );
return FALSE;
}
/* get adjacent face of hexes */
adj_faces = NULL;
adj_faces_alloc = 0;
face_offsets = NULL;
face_offsets_alloc = 0;
iMesh_getEntArrAdj( mesh, hexes, hexes_size, iBase_FACE, &adj_faces, &adj_faces_alloc, &adj_faces_size,
&face_offsets, &face_offsets_alloc, &face_offsets_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem to get adjacent entities in entitysets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
free( all_entities );
free( hexes );
return FALSE;
}
iMesh_createEntSet( mesh, FALSE, &hex_set, &result );
if( iBase_SUCCESS != result )
{
printf( "Problem creating entityset in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
free( all_entities );
free( hexes );
free( adj_faces );
free( face_offsets );
return FALSE;
}
iMesh_addEntArrToSet( mesh, hexes, hexes_size, hex_set, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to add hexes in entity_sets_test.\n" );
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
free( all_entities );
free( hexes );
free( adj_faces );
free( face_offsets );
return FALSE;
}
free( edges );
free( faces );
free( temp_entities1 );
free( temp_entities2 );
free( types );
free( regions );
free( parents );
free( es_array1 );
free( all_entities );
free( hexes );
free( adj_faces );
free( face_offsets );
return TRUE;
}
| int entity_sets_test | ( | iMesh_Instance | mesh | ) |
Definition at line 1650 of file testc_cbind.cpp.
References entity_sets_subtest(), and TRUE.
Referenced by main().
{
int iter_num = 0, result;
/* check */
int i;
for( i = 0; i < 2; i++ )
{
iter_num++;
result = entity_sets_subtest( mesh, i, iter_num );
if( !result ) return result;
}
return TRUE;
}
| int entityset_double_tag_test | ( | iMesh_Instance | mesh, |
| iBase_EntitySetHandle * | sets, | ||
| int | sets_size, | ||
| iBase_TagHandle * | double_tag | ||
| ) |
Definition at line 2156 of file testc_cbind.cpp.
References FALSE, iBase_DOUBLE, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, and TRUE.
Referenced by entityset_tag_test().
{
int result;
double dum_val = 1.0e6, dum_val2;
void* dum_val2_ptr = &dum_val2;
int dum_val2_alloc = sizeof( double ), dum_val2_size;
/* create a tag */
const char* tag_name = "set_double_tag";
iMesh_createTag( mesh, tag_name, 1, iBase_DOUBLE, double_tag, &result, 15 );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag double_tag in entityset_double_tag_test.\n" );
return FALSE;
}
/* put a value in the first set and retrieve */
iMesh_setEntSetData( mesh, sets[0], *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set double tag (val=11) in entityset_double_tag_test.\n" );
return FALSE;
}
dum_val2 = 0;
iMesh_getEntSetData( mesh, sets[0], *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get double tag (val=1.0e6) in entityset_double_tag_test." );
return FALSE;
}
if( dum_val2 != 1.0e6 )
{
printf( "Value of entityset tag (val=11) wrong.\n" );
return FALSE;
}
/* put a value in the last faces and retrieve */
dum_val = 2.0e9;
iMesh_setEntSetData( mesh, sets[sets_size - 1], *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set double tag (val=2.0e9) in entityset_double_tag_test." );
return FALSE;
}
iMesh_getEntSetData( mesh, sets[sets_size - 1], *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size,
&result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get double tag (val=2.0e9) in entityset_double_tag_test." );
return FALSE;
}
if( dum_val2 != 2.0e9 )
{
printf( "Value of entityset tag (val=2.0e9) wrong.\n" );
return FALSE;
}
/* ok, the double tag test worked */
return TRUE;
}
| int entityset_int_tag_test | ( | iMesh_Instance | mesh, |
| iBase_EntitySetHandle * | sets, | ||
| int | sets_size, | ||
| iBase_TagHandle * | int_tag | ||
| ) |
Definition at line 2091 of file testc_cbind.cpp.
References FALSE, iBase_INTEGER, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, and TRUE.
Referenced by entityset_tag_test().
{
int result;
int dum_val = 11, dum_val2;
void* dum_val2_ptr = &dum_val2;
int dum_val2_alloc = sizeof( int ), dum_val2_size;
/* create a tag */
const char* tag_name = "set_int_tag";
iMesh_createTag( mesh, tag_name, 1, iBase_INTEGER, int_tag, &result, 12 );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag int_tag in entityset_int_tag_test.\n" );
return FALSE;
}
/* put a value in the first set and retrieve */
iMesh_setEntSetData( mesh, sets[0], *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set int tag (val=11) in entityset_int_tag_test.\n" );
return FALSE;
}
dum_val2 = 0;
iMesh_getEntSetData( mesh, sets[0], *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get int tag (val=11) in entityset_int_tag_test." );
return FALSE;
}
if( dum_val2 != 11 )
{
printf( "Value of entityset tag (val=11) wrong.\n" );
return FALSE;
}
/* put a value in the last faces and retrieve */
dum_val = 12;
iMesh_setEntSetData( mesh, sets[sets_size - 1], *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set int tag (val=12) in entityset_int_tag_test." );
return FALSE;
}
iMesh_getEntSetData( mesh, sets[sets_size - 1], *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get int tag (val=12) in entityset_int_tag_test." );
return FALSE;
}
if( dum_val2 != 12 )
{
printf( "Value of entityset tag (val=12) wrong.\n" );
return FALSE;
}
/* ok, the int tag test worked */
return TRUE;
}
| int entityset_struct_tag_test | ( | iMesh_Instance | mesh, |
| iBase_EntitySetHandle * | , | ||
| int | , | ||
| iBase_TagHandle * | struct_tag | ||
| ) |
Definition at line 2225 of file testc_cbind.cpp.
References FALSE, iBase_BYTES, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, root_set, and TRUE.
Referenced by entityset_tag_test().
{
int result;
struct TagStruct dum_struct = { 3.0e12, 2, 3 }, dum_struct2;
void* dum_struct2_ptr = &dum_struct2;
int dum_struct_alloc = sizeof( struct TagStruct ), dum_struct_size;
/* create a tag */
const char* tag_name = "set_struct_tag";
iMesh_createTag( mesh, tag_name, sizeof( struct TagStruct ), iBase_BYTES, struct_tag, &result, 11 );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag struct_tag in entityset_struct_tag_test.\n" );
return FALSE;
}
/* put a value in the first vertex and retrieve */
/* careful setting the value, since tags are opaque */
iMesh_setEntSetData( mesh, root_set, *struct_tag, (const char*)&dum_struct, sizeof( struct TagStruct ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set struct tag in entityset_struct_tag_test.\n" );
return FALSE;
}
iMesh_getEntSetData( mesh, root_set, *struct_tag, &dum_struct2_ptr, &dum_struct_alloc, &dum_struct_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get struct tag in entityset_struct_tag_test.\n" );
return FALSE;
}
if( dum_struct_size != sizeof( struct TagStruct ) )
{
printf( "Size of entityset struct tag wrong.\n" );
return FALSE;
}
if( dum_struct2.test_int1 != dum_struct.test_int1 || dum_struct2.test_int2 != dum_struct.test_int2 ||
dum_struct2.test_double != dum_struct.test_double )
{
printf( "Value of entityset struct tag wrong.\n" );
return FALSE;
}
/* ok, the int tag test worked */
return TRUE;
}
| int entityset_tag_delete_test | ( | iMesh_Instance | mesh, |
| iBase_EntitySetHandle * | sets, | ||
| int | sets_size | ||
| ) |
Definition at line 2277 of file testc_cbind.cpp.
References FALSE, iBase_SUCCESS, iMesh_destroyTag, iMesh_getAllEntSetTags, iMesh_rmvEntSetTag, and TRUE.
Referenced by entityset_tag_test().
{
/* test forced, unforced deletion of tags from entities */
int result;
int delete_err = FALSE;
/* test getAlliBase_TagHandles for first entity */
iBase_TagHandle* all_tags = NULL;
if( sets_size < 1 )
{
printf( "no sets.\n" );
return FALSE;
}
iBase_EntitySetHandle dum_entity = sets[0];
int all_tags_alloc = 0, all_tags_size;
iMesh_getAllEntSetTags( mesh, sets[0], &all_tags, &all_tags_alloc, &all_tags_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't get all tag handles from entityset.\n" );
free( all_tags );
return FALSE;
}
iMesh_rmvEntSetTag( mesh, dum_entity, all_tags[0], &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't remove tag from entityset.\n" );
free( all_tags );
return FALSE;
}
iMesh_destroyTag( mesh, all_tags[1], FALSE, &result );
if( iBase_SUCCESS != result )
{
delete_err = TRUE;
}
if( !delete_err )
{
printf( "Error when unforced-deleting tag in use on a entityset.\n" );
free( all_tags );
return FALSE;
}
iMesh_destroyTag( mesh, all_tags[1], TRUE, &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't force-delete a tag in use on a entityset.\n" );
free( all_tags );
return FALSE;
}
free( all_tags );
/* ok, we're done */
return TRUE;
}
| int entityset_tag_test | ( | iMesh_Instance | mesh | ) |
Definition at line 2339 of file testc_cbind.cpp.
References entityset_double_tag_test(), entityset_int_tag_test(), entityset_struct_tag_test(), entityset_tag_delete_test(), FALSE, iBase_SUCCESS, iMesh_getEntSets, and root_set.
Referenced by main().
{
int result;
iBase_TagHandle int_tag, double_tag, struct_tag;
int int_success, double_success, struct_success, tag_delete_success;
/* get the sets */
iBase_EntitySetHandle* esets = NULL;
int esets_alloc = 0, esets_size;
iMesh_getEntSets( mesh, root_set, 1, &esets, &esets_alloc, &esets_size, &result );
if( iBase_SUCCESS != result )
{
printf( "entitysetGetEntities failed in entityset_tag_test.\n" );
free( esets );
return FALSE;
}
/* entityset int tag */
int_success = entityset_int_tag_test( mesh, esets, esets_size, &int_tag );
/* entityeset double tag */
double_success = entityset_double_tag_test( mesh, esets, esets_size, &double_tag );
/* entityset struct tag */
struct_success = entityset_struct_tag_test( mesh, esets, esets_size, &struct_tag );
tag_delete_success = entityset_tag_delete_test( mesh, esets, esets_size );
free( esets );
return ( int_success && double_success && struct_success && tag_delete_success );
}
| int error_code_test | ( | iMesh_Instance | ) |
Definition at line 151 of file testc_cbind.cpp.
References iBase_FAILURE, iBase_FILE_NOT_FOUND, iBase_INVALID_ARGUMENT, iBase_INVALID_ENTITY_HANDLE, iBase_INVALID_ENTITY_TYPE, iBase_MEMORY_ALLOCATION_FAILED, iBase_NOT_SUPPORTED, iBase_SUCCESS, iBase_TAG_NOT_FOUND, MB_ENTITY_NOT_FOUND, MB_FILE_DOES_NOT_EXIST, MB_MEMORY_ALLOCATION_FAILED, MB_SUCCESS, MB_TAG_NOT_FOUND, MB_TYPE_OUT_OF_RANGE, MB_UNHANDLED_OPTION, MB_UNSUPPORTED_OPERATION, TEST_ERROR_CODE, and TRUE.
Referenced by main().
{
TEST_ERROR_CODE( MB_SUCCESS, iBase_SUCCESS )
TEST_ERROR_CODE( MB_TYPE_OUT_OF_RANGE, iBase_INVALID_ENTITY_TYPE )
TEST_ERROR_CODE( MB_MEMORY_ALLOCATION_FAILED, iBase_MEMORY_ALLOCATION_FAILED )
TEST_ERROR_CODE( MB_ENTITY_NOT_FOUND, iBase_INVALID_ENTITY_HANDLE )
TEST_ERROR_CODE( MB_TAG_NOT_FOUND, iBase_TAG_NOT_FOUND )
TEST_ERROR_CODE( MB_FILE_DOES_NOT_EXIST, iBase_FILE_NOT_FOUND )
TEST_ERROR_CODE( MB_UNSUPPORTED_OPERATION, iBase_NOT_SUPPORTED )
TEST_ERROR_CODE( MB_UNHANDLED_OPTION, iBase_INVALID_ARGUMENT )
TEST_ERROR_CODE( MB_FAILURE, iBase_FAILURE )
return TRUE;
}
| void handle_error_code | ( | const int | result, |
| int * | number_failed, | ||
| int * | , | ||
| int * | number_successful | ||
| ) |
prints out a result string based on the value of error_code
Definition at line 110 of file testc_cbind.cpp.
{
if( result )
{
printf( "Success\n" );
( *number_successful )++;
}
else
{
printf( "Failure\n" );
( *number_failed )++;
}
}
| int load_mesh_test | ( | const char * | filename, |
| iMesh_Instance | mesh | ||
| ) |
Definition at line 129 of file testc_cbind.cpp.
References FALSE, iBase_SUCCESS, iMesh_load, root_set, and TRUE.
Referenced by main().
{
/* load a mesh */
int result;
iMesh_load( mesh, root_set, filename, NULL, &result, strlen( filename ), 0 );
if( iBase_SUCCESS != result )
{
printf( "ERROR : can not load a mesh from file %s\n", filename );
return FALSE;
}
return TRUE;
}
| int main | ( | int | argc, |
| char * | argv[] | ||
| ) |
Definition at line 3093 of file testc_cbind.cpp.
References all_adjacency_regression(), array_allocation(), DEFAULT_INPUT_FILE, entity_connectivity_test(), entity_sets_test(), entityset_tag_test(), error_code_test(), filename, handle_error_code(), iBase_SUCCESS, iMesh_dtor, iMesh_getRootSet, iMesh_newMesh, load_mesh_test(), mesh, mesh_tag_test(), number_tests, number_tests_failed, number_tests_successful, ordered_set_regression(), root_set, set_remove_contained_regression(), test_iterator(), topology_adjacency_test(), topology_dimension_test(), vertex_coordinates_test(), and vertex_tag_test().
{
/* Check command line arg */
const char* filename;
int number_tests = 0;
int number_tests_successful = 0;
int number_tests_not_implemented = 0;
int number_tests_failed = 0;
int result;
iMesh_Instance mesh = NULL;
if( argc == 2 )
{
filename = argv[1];
}
else
{
printf( "Usage: %s <mesh_filename>\n", argv[0] );
if( argc != 1 ) return 1;
printf( " No file specified. Defaulting to: %s\n", DEFAULT_INPUT_FILE );
filename = DEFAULT_INPUT_FILE;
}
/* initialize the Mesh */
iMesh_newMesh( NULL, &mesh, &result, 0 );
if( iBase_SUCCESS != result )
{
printf( "Failed to create a mesh instance.\n" );
return 1;
}
iMesh_getRootSet( mesh, &root_set, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to return a root set.\n" );
return 1;
}
/* Print out Header information */
printf( "\n\nTSTT TEST PROGRAM:\n\n" );
/* load_mesh test */
printf( " load_mesh: " );
result = load_mesh_test( filename, mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* topology_adjacency_test */
printf( " topology_adjacency_test: " );
result = topology_adjacency_test( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* entity connectivity test */
printf( " entity_connectivity_test: " );
result = entity_connectivity_test( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* vertex_coordinates_test */
printf( " vertex_coordinates_test: " );
result = vertex_coordinates_test( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* topology dimension test */
printf( " topology_dimension_test: " );
result = topology_dimension_test( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* entity sets test */
printf( " entity_sets_test: " );
result = entity_sets_test( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* vertex tag test */
printf( " vertex_tag_test: " );
result = vertex_tag_test( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* entityset tag test */
printf( " entityset_tag_test: " );
result = entityset_tag_test( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* mesh tag test */
printf( " mesh_tag_test: " );
result = mesh_tag_test( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* iterator test */
printf( " test_iterator: " );
result = test_iterator( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* regression test for remove/contained bug */
printf( " set_remove_contained_regression: " );
result = set_remove_contained_regression( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* regression test for adjacencies with iBase_ALL_TYPES bug */
printf( " all_adjacency_regression: " );
result = all_adjacency_regression( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* test for error codes */
printf( " error_code_test: " );
result = error_code_test( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* regression test for ordered sets not preserving order */
printf( " ordered_set_regression: " );
result = ordered_set_regression( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* test for array allocation behavior */
printf( " array_allocation_regression: " );
result = array_allocation( mesh );
handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
number_tests++;
printf( "\n" );
/* summary */
printf( "\nTSTT TEST SUMMARY: \n" );
printf( " Number Tests: %d\n", number_tests );
printf( " Number Successful: %d\n", number_tests_successful );
printf( " Number Not Implemented: %d\n", number_tests_not_implemented );
printf( " Number Failed: %d\n", number_tests_failed );
printf( "\n\n\n" );
/* delete the mesh */
iMesh_dtor( mesh, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to destruct the mesh instance.\n" );
return 1;
}
return number_tests_failed;
}
| int mesh_double_tag_test | ( | iMesh_Instance | mesh, |
| iBase_TagHandle * | double_tag | ||
| ) |
Definition at line 2437 of file testc_cbind.cpp.
References FALSE, iBase_DOUBLE, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, root_set, and TRUE.
Referenced by mesh_tag_test().
{
int result;
double dum_val = 1.0e6, dum_val2;
void* dum_val2_ptr = &dum_val2;
int dum_val2_alloc = sizeof( double ), dum_val2_size;
/* create a tag */
const char* tag_name = "mesh_double_tag";
iMesh_createTag( mesh, tag_name, 1, iBase_DOUBLE, double_tag, &result, 15 );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag double_tag in mesh_double_tag_test.\n" );
return FALSE;
}
/* put a value in the first set and retrieve */
iMesh_setEntSetData( mesh, root_set, *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set double tag (val=11) in mesh_double_tag_test.\n" );
return FALSE;
}
dum_val2 = 0;
iMesh_getEntSetData( mesh, root_set, *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get double tag (val=1.0e6) in mesh_double_tag_test." );
return FALSE;
}
if( dum_val2 != 1.0e6 )
{
printf( "Value of entityset tag (val=11) wrong.\n" );
return FALSE;
}
/* put a value in the last faces and retrieve */
dum_val = 2.0e9;
iMesh_setEntSetData( mesh, root_set, *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set double tag (val=2.0e9) in mesh_double_tag_test." );
return FALSE;
}
iMesh_getEntSetData( mesh, root_set, *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get double tag (val=2.0e9) in mesh_double_tag_test." );
return FALSE;
}
if( dum_val2 != 2.0e9 )
{
printf( "Value of entityset tag (val=2.0e9) wrong.\n" );
return FALSE;
}
/* ok, the double tag test worked */
return TRUE;
}
| int mesh_int_tag_test | ( | iMesh_Instance | mesh, |
| iBase_TagHandle * | int_tag | ||
| ) |
Definition at line 2372 of file testc_cbind.cpp.
References FALSE, iBase_INTEGER, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, root_set, and TRUE.
Referenced by mesh_tag_test().
{
int result;
int dum_val = 11, dum_val2;
void* dum_val2_ptr = &dum_val2;
int dum_val2_alloc = sizeof( int ), dum_val2_size;
/* create a tag */
const char* tag_name = "mesh_int_tag";
iMesh_createTag( mesh, tag_name, 1, iBase_INTEGER, int_tag, &result, 12 );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag int_tag in mesh_int_tag_test.\n" );
return FALSE;
}
/* put a value in the first set and retrieve */
iMesh_setEntSetData( mesh, root_set, *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set int tag (val=11) in mesh_int_tag_test.\n" );
return FALSE;
}
dum_val2 = 0;
iMesh_getEntSetData( mesh, root_set, *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get int tag (val=11) in mesh_int_tag_test." );
return FALSE;
}
if( dum_val2 != 11 )
{
printf( "Value of entityset tag (val=11) wrong.\n" );
return FALSE;
}
/* put a value in the last faces and retrieve */
dum_val = 12;
iMesh_setEntSetData( mesh, root_set, *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set int tag (val=12) in mesh_int_tag_test." );
return FALSE;
}
iMesh_getEntSetData( mesh, root_set, *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get int tag (val=12) in mesh_int_tag_test." );
return FALSE;
}
if( dum_val2 != 12 )
{
printf( "Value of entityset tag (val=12) wrong.\n" );
return FALSE;
}
/* ok, the int tag test worked */
return TRUE;
}
| int mesh_struct_tag_test | ( | iMesh_Instance | mesh, |
| iBase_TagHandle * | struct_tag | ||
| ) |
Definition at line 2502 of file testc_cbind.cpp.
References FALSE, iBase_BYTES, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, root_set, and TRUE.
Referenced by mesh_tag_test().
{
int result;
struct TagStruct dum_struct = { 3.0e12, 2, 3 }, dum_struct2;
void* dum_struct2_ptr = &dum_struct2;
int dum_struct_alloc = sizeof( struct TagStruct ), dum_struct_size;
/* create a tag */
const char* tag_name = "mesh_struct_tag";
iMesh_createTag( mesh, tag_name, sizeof( struct TagStruct ), iBase_BYTES, struct_tag, &result, 11 );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag struct_tag in vertex_struct_tag_test.\n" );
return FALSE;
}
/* put a value in the first vertex and retrieve */
/* careful setting the value, since tags are opaque */
iMesh_setEntSetData( mesh, root_set, *struct_tag, (const char*)&dum_struct, sizeof( struct TagStruct ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set struct tag in mesh_struct_tag_test.\n" );
return FALSE;
}
iMesh_getEntSetData( mesh, root_set, *struct_tag, &dum_struct2_ptr, &dum_struct_alloc, &dum_struct_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get struct tag in mesh_struct_tag_test.\n" );
return FALSE;
}
if( dum_struct_size != sizeof( struct TagStruct ) )
{
printf( "Size of entityset struct tag wrong.\n" );
return FALSE;
}
if( dum_struct2.test_int1 != dum_struct.test_int1 || dum_struct2.test_int2 != dum_struct.test_int2 ||
dum_struct2.test_double != dum_struct.test_double )
{
printf( "Value of entityset struct tag wrong.\n" );
return FALSE;
}
/* ok, the int tag test worked */
return TRUE;
}
| int mesh_tag_delete_test | ( | iMesh_Instance | mesh | ) |
Definition at line 2551 of file testc_cbind.cpp.
References FALSE, iBase_SUCCESS, iMesh_destroyTag, iMesh_getAllEntSetTags, iMesh_rmvEntSetTag, root_set, and TRUE.
Referenced by mesh_tag_test().
{
/* test forced, unforced deletion of tags from entities */
int result;
int delete_err = FALSE;
/* test getAlliBase_TagHandles for first entity */
iBase_TagHandle* all_tags = NULL;
int all_tags_alloc = 0, all_tags_size;
iMesh_getAllEntSetTags( mesh, root_set, &all_tags, &all_tags_alloc, &all_tags_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't get all tag handles from entityset.\n" );
return FALSE;
}
iMesh_rmvEntSetTag( mesh, root_set, all_tags[0], &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't remove tag from entityset.\n" );
free( all_tags );
return FALSE;
}
iMesh_destroyTag( mesh, all_tags[1], FALSE, &result );
if( iBase_SUCCESS != result )
{
delete_err = TRUE;
}
if( !delete_err )
{
printf( "Error when unforced-deleting tag in use on a entityset.\n" );
free( all_tags );
return FALSE;
}
iMesh_destroyTag( mesh, all_tags[1], TRUE, &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't force-delete a tag in use on a entityset.\n" );
free( all_tags );
return FALSE;
}
free( all_tags );
/* ok, we're done */
return TRUE;
}
| int mesh_tag_test | ( | iMesh_Instance | mesh | ) |
Definition at line 2606 of file testc_cbind.cpp.
References mesh_double_tag_test(), mesh_int_tag_test(), mesh_struct_tag_test(), and mesh_tag_delete_test().
Referenced by main().
{
iBase_TagHandle int_tag, double_tag, struct_tag;
/* entityset int tag */
int int_success = mesh_int_tag_test( mesh, &int_tag );
/* entityeset double tag */
int double_success = mesh_double_tag_test( mesh, &double_tag );
/* entityset struct tag */
int struct_success = mesh_struct_tag_test( mesh, &struct_tag );
int tag_delete_success = mesh_tag_delete_test( mesh );
return ( int_success && double_success && struct_success && tag_delete_success );
}
| static int ordered_set_regression | ( | iMesh_Instance | mesh | ) | [static] |
Definition at line 2711 of file testc_cbind.cpp.
References CHK, iBase_ALL_TYPES, iBase_INTERLEAVED, iBase_NEW, iMesh_addEntArrToSet, iMesh_ALL_TOPOLOGIES, iMesh_createEnt, iMesh_createEntSet, iMesh_createVtxArr, iMesh_dtor, iMesh_getEntities, iMesh_LINE_SEGMENT, and iMesh_newMesh.
Referenced by main().
{
double coords[] = { 0, 0, 0, 1, 1, 1 };
iBase_EntityHandle line, *p, verts[2], ents_in[3], ents_out[3];
iBase_EntitySetHandle set;
int i, err, status, two = 2, three = 3;
iMesh_newMesh( "", &mesh, &err, 0 );
CHK( err );
p = verts;
iMesh_createVtxArr( mesh, 2, iBase_INTERLEAVED, coords, 6, &p, &two, &two, &err );
CHK( err );
iMesh_createEnt( mesh, iMesh_LINE_SEGMENT, verts, 2, &line, &status, &err );
CHK( err );
if( status != iBase_NEW ) return 0;
iMesh_createEntSet( mesh, 1, &set, &err );
CHK( err );
ents_in[0] = verts[1];
ents_in[1] = line;
ents_in[2] = verts[0];
iMesh_addEntArrToSet( mesh, ents_in, three, set, &err );
CHK( err );
p = ents_out;
iMesh_getEntities( mesh, set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &p, &three, &three, &err );
CHK( err );
for( i = 0; i < three; i++ )
{
if( ents_in[i] != ents_out[i] )
{
printf( "Ordered set does not preserve order\n" );
return 0;
}
}
iMesh_dtor( mesh, &err );
CHK( err );
return 1;
}
| void PRINT_ASSERT_FAILURE | ( | const char * | cond, |
| const char * | file, | ||
| int | line | ||
| ) |
Definition at line 90 of file testc_cbind.cpp.
{
printf( "Condition: %s\n", cond );
printf( " failed at %s line %d\n", file, line );
}
| int qsort_comp_handles | ( | const void * | h1, |
| const void * | h2 | ||
| ) |
Definition at line 503 of file testc_cbind.cpp.
Referenced by entity_connectivity_test().
{
return *(char**)h1 - *(char**)h2;
}
| int set_remove_contained_regression | ( | iMesh_Instance | mesh | ) |
Definition at line 2624 of file testc_cbind.cpp.
References contained(), iBase_SUCCESS, iMesh_addEntSet, iMesh_createEntSet, iMesh_isEntSetContained, and iMesh_rmvEntSet.
Referenced by main().
{
int err, contained;
iBase_EntitySetHandle set, sub;
iMesh_createEntSet( mesh, 0, &set, &err );
if( iBase_SUCCESS != err ) return 0;
iMesh_createEntSet( mesh, 1, &sub, &err );
if( iBase_SUCCESS != err ) return 0;
iMesh_addEntSet( mesh, sub, set, &err );
if( iBase_SUCCESS != err ) return 0;
iMesh_isEntSetContained( mesh, set, sub, &contained, &err );
if( iBase_SUCCESS != err ) return 0;
if( !contained )
{
fprintf( stderr, "isEntSetContained returned false for contained set\n" );
return 0;
}
iMesh_rmvEntSet( mesh, sub, set, &err );
if( iBase_SUCCESS != err ) return 0;
iMesh_isEntSetContained( mesh, set, sub, &contained, &err );
if( iBase_SUCCESS != err ) return 0;
if( contained )
{
fprintf( stderr, "isEntSetContained returned true for removed set\n" );
return 0;
}
return 1;
}
| int tag_info_test | ( | iMesh_Instance | mesh | ) |
Definition at line 1724 of file testc_cbind.cpp.
References moab::error(), FALSE, iBase_INTEGER, iBase_SUCCESS, iMesh_createTag, iMesh_destroyTag, iMesh_getTagHandle, iMesh_getTagName, iMesh_getTagSizeBytes, and TRUE.
{
char dum_name[120];
int dum_name_size = 120;
int dum_size;
int error = FALSE;
iBase_TagHandle dum_handle;
/* Create a tag */
int result;
iBase_TagHandle tag_handle = NULL;
const char* tag_name = "int_tag";
int tag_name_size = 8;
iMesh_createTag( mesh, tag_name, 1, iBase_INTEGER, &tag_handle, &result, tag_name_size );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag int_tag in vertex_tag_test." );
return FALSE;
}
/* check tag info functions */
iMesh_getTagName( mesh, tag_handle, dum_name, &result, dum_name_size );
if( iBase_SUCCESS != result )
{
printf( "Couldn't get name of tag just created.\n" );
return FALSE;
}
if( strcmp( dum_name, "int_tag" ) != 0 )
{
printf( "Tag names didn't match.\n" );
return FALSE;
}
iMesh_getTagSizeBytes( mesh, tag_handle, &dum_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't get size of tag just created.\n" );
return FALSE;
}
if( dum_size != sizeof( int ) )
{
printf( "Tag sizes didn't match.\n" );
return FALSE;
}
iMesh_getTagHandle( mesh, tag_name, &dum_handle, &result, tag_name_size );
if( iBase_SUCCESS != result )
{
printf( "Couldn't get handle of tag just created.\n" );
return FALSE;
}
if( dum_handle != tag_handle )
{
printf( "Tag handles didn't match.\n" );
return FALSE;
}
/* test non-forced version of tagDelete; forced version tested later, */
/* when we have entities around */
iMesh_destroyTag( mesh, tag_handle, FALSE, &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't delete tag just created.\n" );
return FALSE;
}
/* look for that tag, to make sure it got deleted */
iMesh_getTagHandle( mesh, tag_name, &tag_handle, &result, tag_name_size );
if( iBase_SUCCESS != result )
{
error = TRUE;
}
if( !error )
{
printf( "tagGetHandle was able to find handle for deleted tag.\n" );
return FALSE;
}
return TRUE;
}
| int test_iterator | ( | iMesh_Instance | mesh | ) |
Definition at line 3027 of file testc_cbind.cpp.
References CHK, iBase_ALL_TYPES, iBase_SUCCESS, iMesh_addEntArrToSet, iMesh_ALL_TOPOLOGIES, iMesh_createEntSet, iMesh_getEntities, iMesh_getRootSet, and test_iterator_common().
Referenced by main(), and test_iterators().
{
int result, i;
iBase_EntitySetHandle root, list, set, *setptr;
iBase_EntityHandle* array = NULL;
int array_len = 0, array_size = 0;
iMesh_getRootSet( mesh, &root, &result );
CHK( result );
/* create some sets containing every other handle */
iMesh_getEntities( mesh, root, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &array, &array_size, &array_len, &result );
CHK( result );
for( i = 1; i < array_size; i += 2 )
array[i] = array[i - 1];
for( i = 0; i < 2; ++i )
{
setptr = i ? &list : &set;
iMesh_createEntSet( mesh, i, setptr, &result );
if( iBase_SUCCESS != result ) free( array );
CHK( result );
iMesh_addEntArrToSet( mesh, array, array_size, *setptr, &result );
if( iBase_SUCCESS != result ) free( array );
CHK( result );
}
free( array );
/* test single iterator and array iterator for all types */
for( i = 0; i < iBase_ALL_TYPES; ++i )
{
array_size = 2 * i + 2;
result = test_iterator_common( "root", mesh, root, 1, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
CHK( result );
result = test_iterator_common( "root", mesh, root, array_size, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
CHK( result );
result = test_iterator_common( "list", mesh, list, 1, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
CHK( result );
result = test_iterator_common( "list", mesh, list, array_size, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
CHK( result );
result = test_iterator_common( "set", mesh, set, 1, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
CHK( result );
result = test_iterator_common( "set", mesh, set, array_size, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
CHK( result );
}
/* test single iterator and array iterator for all types */
for( i = 0; i < iMesh_ALL_TOPOLOGIES; ++i )
{
array_size = 2 * i + 2;
result = test_iterator_common( "root", mesh, root, 1, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
CHK( result );
result = test_iterator_common( "root", mesh, root, array_size, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
CHK( result );
result = test_iterator_common( "list", mesh, list, 1, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
CHK( result );
result = test_iterator_common( "list", mesh, list, array_size, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
CHK( result );
result = test_iterator_common( "set", mesh, set, 1, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
CHK( result );
result = test_iterator_common( "set", mesh, set, array_size, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
CHK( result );
}
return 1;
}
| int test_iterator_common | ( | const char * | info, |
| iMesh_Instance | mesh, | ||
| iBase_EntitySetHandle | set, | ||
| int | array_size, | ||
| enum iBase_EntityType | type, | ||
| enum iMesh_EntityTopology | topo | ||
| ) |
Definition at line 3006 of file testc_cbind.cpp.
References CHK, compare_array_iter(), compare_single_iter(), and iMesh_getEntities.
Referenced by test_iterator().
{
iBase_EntityHandle* contents = NULL;
int content_size = 0, content_alloc = 0;
int result;
iMesh_getEntities( mesh, set, type, topo, &contents, &content_alloc, &content_size, &result );
CHK( result );
if( array_size == 1 )
result = compare_single_iter( info, mesh, set, contents, content_size, type, topo );
else
result = compare_array_iter( info, mesh, set, contents, content_size, array_size, type, topo );
free( contents );
return result;
}
| int topology_adjacency_test | ( | iMesh_Instance | mesh | ) |
Definition at line 229 of file testc_cbind.cpp.
References entities, FALSE, iBase_ALL_TYPES, iBase_FACE, iBase_REGION, iBase_SUCCESS, iMesh_ALL_TOPOLOGIES, iMesh_getEntArrAdj, iMesh_getEntArrTopo, iMesh_getEntities, iMesh_getNumOfTopo, iMesh_HEXAHEDRON, iMesh_POINT, iMesh_PRISM, iMesh_PYRAMID, iMesh_SEPTAHEDRON, iMesh_TETRAHEDRON, root_set, and TRUE.
Referenced by main().
{
int result, i, j, entities_alloc, entities_size, *topologies;
int topologies_alloc, topologies_size;
iBase_EntityHandle *entities, *entity_vectors[iMesh_ALL_TOPOLOGIES] = { NULL };
int entity_vectors_sizes[iMesh_ALL_TOPOLOGIES] = { 0 };
int top_j, num_tops, region_type, num_region;
iBase_EntityHandle* adj_faces = NULL;
int adj_faces_alloc = 0, adj_faces_size;
int* face_offsets = NULL;
int face_offsets_alloc = 0, face_offsets_size, face_loaded;
iBase_EntityHandle* adj_regions = NULL;
int adj_regions_alloc = 0, adj_regions_size;
int* region_offsets = NULL;
int region_offsets_alloc = 0, region_offsets_size;
iBase_EntityHandle *interior, *exterior;
int num_int = 0, num_ext = 0, found, next_offset, iter;
int num_faces_per_region;
;
/* fill the vectors of each topology entities */
/* like lines vector, polygon vector, triangle vector, */
/* quadrilateral, polyhedrron, tet, hex, prism, pyramid, */
/* septahedron vectors */
for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
{
entities = NULL;
entities_alloc = 0;
iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, i, &entities, &entities_alloc, &entities_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get entities in adjacencies_test.\n" );
return FALSE;
}
if( entities_alloc > 0 )
{
topologies = NULL;
topologies_alloc = 0;
iMesh_getEntArrTopo( mesh, entities, entities_alloc, &topologies, &topologies_alloc, &topologies_size,
&result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get topologies in adjacencies_test.\n" );
return FALSE;
}
if( topologies_size != entities_size )
{
printf( "Didn't get the right number of topologies "
"in topology_adjacency_test.\n" );
free( topologies );
free( entities );
return FALSE;
}
/* put entities into vectors of each topology */
entity_vectors[i] = (iBase_EntityHandle*)malloc( entities_size * sizeof( iBase_EntityHandle ) );
for( j = 0; j < entities_size; j++ )
{
if( topologies[j] < iMesh_POINT || topologies[j] >= iMesh_ALL_TOPOLOGIES )
printf( "Didn't find entity type for this topology." );
else
{
entity_vectors[i][entity_vectors_sizes[i]] = entities[j];
entity_vectors_sizes[i]++;
}
}
free( topologies );
}
free( entities );
}
/* check number of entities for each topology */
for( top_j = 0; top_j < iMesh_ALL_TOPOLOGIES; top_j++ )
{
num_tops = 0;
iMesh_getNumOfTopo( mesh, root_set, top_j, &num_tops, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get number of topologies in adjacencies_test.\n" );
for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
free( entity_vectors[i] );
return FALSE;
}
if( entity_vectors_sizes[top_j] != num_tops )
{
printf( "Topology count mismatch.\n" );
for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
free( entity_vectors[i] );
return FALSE;
}
}
/* change if 3d topology entities are added or removed */
for( region_type = iMesh_TETRAHEDRON; region_type < iMesh_ALL_TOPOLOGIES; region_type++ )
{
/* get all adjacent faces of regions */
iBase_EntityHandle* region_vector = entity_vectors[region_type];
num_region = entity_vectors_sizes[region_type];
if( num_region > 0 )
{
adj_faces = NULL;
adj_faces_alloc = 0;
face_offsets = NULL;
face_offsets_alloc = 0;
iMesh_getEntArrAdj( mesh, region_vector, num_region, iBase_FACE, &adj_faces, &adj_faces_alloc,
&adj_faces_size, &face_offsets, &face_offsets_alloc, &face_offsets_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get adjacent faces of regions in adjacencies_test.\n" );
for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
free( entity_vectors[i] );
return FALSE;
}
if( num_region + 1 != face_offsets_size )
{
printf( "Number of offsets didn't agree with number of "
"regions in topology_adjacency_test.\n" );
free( face_offsets );
free( adj_faces );
for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
free( entity_vectors[i] );
return FALSE;
}
face_loaded = FALSE;
/* check # of faces really loaded */
if( region_type == iMesh_TETRAHEDRON )
{
if( adj_faces_size == 4 * num_region ) face_loaded = TRUE;
}
else if( region_type == iMesh_HEXAHEDRON )
{
if( adj_faces_size == 6 * num_region ) face_loaded = TRUE;
}
else if( region_type == iMesh_PRISM )
{
if( adj_faces_size == 5 * num_region ) face_loaded = TRUE;
}
else if( region_type == iMesh_PYRAMID )
{
if( adj_faces_size == 5 * num_region ) face_loaded = TRUE;
}
else if( region_type == iMesh_SEPTAHEDRON )
{
if( adj_faces_size == 7 * num_region ) face_loaded = TRUE;
}
else
face_loaded = FALSE;
/* get all adjacent regions of adjacent faces */
adj_regions = NULL;
adj_regions_alloc = 0;
region_offsets = NULL;
region_offsets_alloc = 0;
iMesh_getEntArrAdj( mesh, adj_faces, adj_faces_size, iBase_REGION, &adj_regions, &adj_regions_alloc,
&adj_regions_size, ®ion_offsets, ®ion_offsets_alloc, ®ion_offsets_size,
&result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get regions from faces in adjacencies_test.\n" );
free( face_offsets );
free( adj_faces );
for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
free( entity_vectors[i] );
return FALSE;
}
if( adj_faces_size + 1 != region_offsets_size )
{
printf( "Number of offsets didn't agree with number of faces in "
"topology_adjacency_test.\n" );
free( face_offsets );
free( region_offsets );
free( adj_faces );
free( adj_regions );
for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
free( entity_vectors[i] );
return FALSE;
}
interior = (iBase_EntityHandle*)malloc( adj_faces_size * sizeof( iBase_EntityHandle ) ),
exterior = (iBase_EntityHandle*)malloc( adj_faces_size * sizeof( iBase_EntityHandle ) );
num_int = 0;
num_ext = 0;
/* find the interior faces having two adjacent regions */
for( i = 0; i < adj_faces_size; i++ )
{
next_offset = 0;
if( i == adj_faces_size - 1 )
next_offset = adj_regions_size;
else
next_offset = region_offsets[i + 1];
if( next_offset - region_offsets[i] == 2 )
{
found = FALSE;
for( iter = 0; iter < num_int; iter++ )
{
if( interior[iter] == adj_faces[i] )
{
found = TRUE;
break;
}
}
if( !found ) interior[num_int++] = adj_faces[i];
}
}
/* now remove any interior faces from the previous adjacent faces list */
/* and we should be left with exterior faces */
for( i = 0; i < adj_faces_size; i++ )
{
found = FALSE;
for( iter = 0; iter < num_int; iter++ )
{
if( interior[iter] == adj_faces[i] )
{
found = TRUE;
break;
}
}
if( !found ) exterior[num_ext++] = adj_faces[i];
}
num_faces_per_region = face_offsets[1] - face_offsets[0];
/* check # of exterior and interior faces */
/* should be #exterior_faces + 2 * #interior_faces = #faces_per_region */
/* * #regions */
if( face_loaded )
{
if( num_ext + 2 * num_int != num_faces_per_region * num_region )
{
printf( "exterior/interior failure: %d ext, %d int, %d regions, %d faces per\n", num_ext, num_int,
num_region, num_faces_per_region );
free( face_offsets );
free( region_offsets );
free( adj_faces );
free( adj_regions );
free( interior );
free( exterior );
for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
free( entity_vectors[i] );
return FALSE;
}
}
free( face_offsets );
free( region_offsets );
free( adj_faces );
free( adj_regions );
free( interior );
free( exterior );
}
}
for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
free( entity_vectors[i] );
return TRUE;
}
| int topology_dimension_test | ( | iMesh_Instance | mesh | ) |
Definition at line 170 of file testc_cbind.cpp.
References FALSE, iBase_FACE, iBase_SUCCESS, iMesh_ALL_TOPOLOGIES, iMesh_getEntArrType, iMesh_getEntities, root_set, and TRUE.
Referenced by main().
{
iBase_EntityHandle* faces = NULL;
int faces_alloc = 0, faces_size;
int result, i;
int* dimensions = NULL;
int dimensions_alloc = 0, dimensions_size;
/* first get 2D entities */
iMesh_getEntities( mesh, root_set, iBase_FACE, iMesh_ALL_TOPOLOGIES, &faces, &faces_alloc, &faces_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get faces in entity_sets_test.\n" );
return FALSE;
}
/* get dimensions of faces */
iMesh_getEntArrType( mesh, faces, faces_size, &dimensions, &dimensions_alloc, &dimensions_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get dimensions of faces in topology_test.\n" );
free( faces );
return FALSE;
}
if( dimensions_size != faces_size )
{
printf( "Didn't get the right number of types in topology_test.\n" );
free( faces );
free( dimensions );
return FALSE;
}
/* make sure all elements are 2D */
for( i = 0; i < faces_size; i++ )
{
if( dimensions[i] != iBase_FACE )
{
free( faces );
free( dimensions );
return FALSE;
}
}
free( faces );
free( dimensions );
return TRUE;
}
| int vertex_coordinates_test | ( | iMesh_Instance | mesh | ) |
Definition at line 1671 of file testc_cbind.cpp.
References FALSE, iBase_INTERLEAVED, iBase_SUCCESS, iBase_VERTEX, iMesh_getDfltStorage, iMesh_getEntities, iMesh_getVtxArrCoords, iMesh_POINT, root_set, and TRUE.
Referenced by main().
{
iBase_EntityHandle* verts = NULL;
int verts_alloc = 0, verts_size;
double* vert_coords = NULL;
int vert_coords_alloc = 0, vert_coords_size;
/* check storage order */
int result;
int this_order;
iMesh_getDfltStorage( mesh, &this_order, &result );
if( iBase_SUCCESS != result )
{
printf( "failed to get preferred storage order in vertex_coordinates_test.\n" );
return FALSE;
}
/* now get the vertex coordinates from a vertex array */
/* need to get the vertices in the model */
verts = NULL;
verts_alloc = 0;
iMesh_getEntities( mesh, root_set, iBase_VERTEX, iMesh_POINT, &verts, &verts_alloc, &verts_size, &result );
if( iBase_SUCCESS != result )
{
printf( "failed to get entities in vertex_coordinates_test.\n" );
return FALSE;
}
/* get the coordinates in one array */
vert_coords = NULL;
vert_coords_alloc = 0;
iMesh_getVtxArrCoords( mesh, verts, verts_size, iBase_INTERLEAVED, &vert_coords, &vert_coords_alloc,
&vert_coords_size, &result );
if( iBase_SUCCESS != result )
{
printf( "failed to get vertex cooridinate of entities in vertex_coordinates_test.\n" );
free( verts );
return FALSE;
}
free( verts );
free( vert_coords );
/* if we get here, this test was successful */
return TRUE;
}
| int vertex_double_tag_test | ( | iMesh_Instance | mesh, |
| iBase_EntityHandle * | verts, | ||
| int | , | ||
| iBase_TagHandle * | double_tag | ||
| ) |
Definition at line 1873 of file testc_cbind.cpp.
References FALSE, iBase_DOUBLE, iBase_SUCCESS, iMesh_createTag, iMesh_getArrData, iMesh_setArrData, and TRUE.
Referenced by vertex_tag_test().
{
int result;
iBase_EntityHandle dum_vert = verts[0];
double dum_val = 1.0e6, dum_val2;
void* dum_val2_ptr = &dum_val2;
int dum_val2_alloc = sizeof( double ), dum_val2_size;
/* create a tag */
const char* tag_name = "double_tag";
int tag_name_size = 11;
iMesh_createTag( mesh, tag_name, 1, iBase_DOUBLE, double_tag, &result, tag_name_size );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag double_tag in vertex_double_tag_test.\n" );
return FALSE;
}
/* put a value in the first vertex and retrieve */
iMesh_setArrData( mesh, &dum_vert, 1, *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set double tag (val=1.0e6) in vertex_double_tag_test.\n" );
return FALSE;
}
iMesh_getArrData( mesh, &dum_vert, 1, *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get double tag (val=1.0e6) in vertex_double_tag_test.\n" );
return FALSE;
}
if( dum_val2 != 1.0e6 )
{
printf( "Value of vertex tag (val=1.0e6) wrong.\n" );
return FALSE;
}
/* put a value in the last vertex and retrieve */
dum_val = 2.0e9;
iMesh_setArrData( mesh, &dum_vert, 1, *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set double tag (val=2.0e9) in vertex_double_tag_test.\n" );
return FALSE;
}
iMesh_getArrData( mesh, &dum_vert, 1, *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get double tag (val=2.0e9) in vertex_double_tag_test.\n" );
return FALSE;
}
if( dum_val2 != 2.0e9 )
{
printf( "Value of vertex tag (val=2.0e9) wrong.\n" );
return FALSE;
}
/* ok, the double tag test worked */
return TRUE;
}
| int vertex_int_tag_test | ( | iMesh_Instance | mesh, |
| iBase_EntityHandle * | verts, | ||
| int | , | ||
| iBase_TagHandle * | int_tag | ||
| ) |
Definition at line 1804 of file testc_cbind.cpp.
References FALSE, iBase_INTEGER, iBase_SUCCESS, iMesh_createTag, iMesh_getArrData, iMesh_setArrData, and TRUE.
Referenced by vertex_tag_test().
{
int result;
iBase_EntityHandle dum_vert = verts[0];
int dum_val = 11, dum_val2;
void* dum_val2_ptr = &dum_val2;
int dum_val2_alloc = sizeof( int ), dum_val2_size;
/* create a tag */
const char* tag_name = "int_tag";
int tag_name_size = 8;
iMesh_createTag( mesh, tag_name, 1, iBase_INTEGER, int_tag, &result, tag_name_size );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag int_tag in vertex_int_tag_test.\n" );
return FALSE;
}
/* put a value in the first vertex and retrieve */
iMesh_setArrData( mesh, &dum_vert, 1, *int_tag, (const char*)( &dum_val ), sizeof( int ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set int tag (val=11) in vertex_int_tag_test.\n" );
return FALSE;
}
iMesh_getArrData( mesh, &dum_vert, 1, *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result || dum_val2 != 11 )
{
printf( "Failed to get int tag (val=11) in vertex_int_tag_test.\n" );
return FALSE;
}
if( dum_val2 != 11 )
{
printf( "Value of vertex tag (val=11) wrong.\n" );
return FALSE;
}
/* put a value in the last vertex and retrieve */
dum_val = 12;
iMesh_setArrData( mesh, &dum_vert, 1, *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set int tag (val=12) in vertex_int_tag_test.\n" );
return FALSE;
}
iMesh_getArrData( mesh, &dum_vert, 1, *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get int tag (val=12) in vertex_int_tag_test.\n" );
return FALSE;
}
if( dum_val2 != 12 )
{
printf( "Value of vertex tag (val=12) wrong.\n" );
return FALSE;
}
/* ok, the int tag test worked */
return TRUE;
}
| int vertex_struct_tag_test | ( | iMesh_Instance | mesh, |
| iBase_EntityHandle * | verts, | ||
| int | , | ||
| iBase_TagHandle * | struct_tag | ||
| ) |
Definition at line 1950 of file testc_cbind.cpp.
References FALSE, iBase_BYTES, iBase_SUCCESS, iMesh_createTag, iMesh_getArrData, iMesh_setArrData, and TRUE.
Referenced by vertex_tag_test().
{
int result;
iBase_EntityHandle dum_vert = verts[0];
struct TagStruct dum_struct = { 3.0e12, 2, 3 }, dum_struct2;
void* dum_struct2_ptr = &dum_struct2;
int dum_struct_alloc = sizeof( struct TagStruct ), dum_struct_size;
/* create a tag */
const char* tag_name = "struct_tag";
int tag_name_size = 11;
iMesh_createTag( mesh, tag_name, sizeof( struct TagStruct ), iBase_BYTES, struct_tag, &result, tag_name_size );
if( iBase_SUCCESS != result )
{
printf( "Failed to create tag struct_tag in vertex_struct_tag_test.\n" );
return FALSE;
}
/* put a value in the first vertex and retrieve */
/* careful setting the value, since tags are opaque */
iMesh_setArrData( mesh, &dum_vert, 1, *struct_tag, (const char*)&dum_struct, sizeof( struct TagStruct ), &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to set struct tag in vertex_struct_tag_test.\n" );
return FALSE;
}
iMesh_getArrData( mesh, &dum_vert, 1, *struct_tag, &dum_struct2_ptr, &dum_struct_alloc, &dum_struct_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Failed to get struct tag in vertex_struct_tag_test.\n" );
return FALSE;
}
if( dum_struct_size != sizeof( struct TagStruct ) )
{
printf( "Size of vertex struct tag wrong.\n" );
return FALSE;
}
if( dum_struct2.test_int1 != dum_struct.test_int1 || dum_struct2.test_int2 != dum_struct.test_int2 ||
dum_struct2.test_double != dum_struct.test_double )
{
printf( "Value of vertex struct tag wrong.\n" );
return FALSE;
}
/* ok, the int tag test worked */
return TRUE;
}
| int vertex_tag_delete_test | ( | iMesh_Instance | mesh, |
| iBase_EntityHandle * | verts, | ||
| int | |||
| ) |
Definition at line 2004 of file testc_cbind.cpp.
References FALSE, iBase_SUCCESS, iMesh_destroyTag, iMesh_getAllTags, iMesh_rmvArrTag, and TRUE.
Referenced by vertex_tag_test().
{
int result;
int delete_err = FALSE;
/* test forced, unforced deletion of tags from entities */
/* test getAlliBase_TagHandles for first entity */
iBase_TagHandle* all_tags = NULL;
iBase_EntityHandle dum_entity = verts[0];
int all_tags_alloc = 0, all_tags_size;
iMesh_getAllTags( mesh, verts[0], &all_tags, &all_tags_alloc, &all_tags_size, &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't get all tag handles from vertex.\n" );
return FALSE;
}
iMesh_rmvArrTag( mesh, &dum_entity, 1, all_tags[0], &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't remove tag from vertex.\n" );
free( all_tags );
return FALSE;
}
iMesh_destroyTag( mesh, all_tags[1], FALSE, &result );
if( iBase_SUCCESS != result )
{
delete_err = TRUE;
}
if( !delete_err )
{
printf( "Error when unforced-deleting tag in use on a vertex.\n" );
free( all_tags );
return FALSE;
}
iMesh_destroyTag( mesh, all_tags[1], TRUE, &result );
if( iBase_SUCCESS != result )
{
printf( "Couldn't force-delete a tag in use on a vertex.\n" );
free( all_tags );
return FALSE;
}
free( all_tags );
/* ok, we're done */
return TRUE;
}
| int vertex_tag_test | ( | iMesh_Instance | mesh | ) |
Definition at line 2056 of file testc_cbind.cpp.
References FALSE, iBase_ALL_TYPES, iBase_SUCCESS, iMesh_getEntities, iMesh_POINT, root_set, tag_info_test(), vertex_double_tag_test(), vertex_int_tag_test(), vertex_struct_tag_test(), and vertex_tag_delete_test().
Referenced by main().
{
int result;
iBase_TagHandle int_tag, double_tag, struct_tag;
int int_err, double_err, struct_err, tag_delete_err;
int info_err = tag_info_test( mesh );
/* get all the vertices */
iBase_EntityHandle* verts = NULL;
int verts_alloc = 0, verts_size;
iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_POINT, &verts, &verts_alloc, &verts_size, &result );
if( iBase_SUCCESS != result )
{
printf( "entitysetGetEntities failed in vertex_tag_test.\n" );
return FALSE;
}
/* vertex int tag */
int_err = vertex_int_tag_test( mesh, verts, verts_size, &int_tag );
/* vertex double tag */
double_err = vertex_double_tag_test( mesh, verts, verts_size, &double_tag );
/* vertex struct tag */
struct_err = vertex_struct_tag_test( mesh, verts, verts_size, &struct_tag );
tag_delete_err = vertex_tag_delete_test( mesh, verts, verts_size );
free( verts );
return ( info_err && int_err && double_err && struct_err && tag_delete_err );
}
bool assert_pass [static] |
Definition at line 81 of file testc_cbind.cpp.
Referenced by entity_connectivity_test().
| enum iBase_ErrorType iBase_ERROR_MAP[MB_FAILURE+1] |
Definition at line 12 of file FBiGeom_MOAB.hpp.
Referenced by iMesh_destroyTag(), iMesh_rmvArrTag(), iMesh_rmvEntSetTag(), iMeshP_getPartsArrOnRank(), iMeshP_getPartsOnRank(), and MBiMesh::set_last_error().
iBase_EntitySetHandle root_set [static] |
Definition at line 105 of file testc_cbind.cpp.
Referenced by advection(), array_allocation(), check_esets(), create_mesh(), DirectAccessNoHolesF90(), entity_connectivity_test(), entity_sets_subtest(), entityset_struct_tag_test(), entityset_tag_test(), findadjacency(), gentityset_test(), geometry_evaluation_test(), get_imesh_mesh(), get_itaps_domain(), gLoad_test(), imeshp_test(), ListSetsNTags(), load_mesh_test(), main(), mesh_double_tag_test(), mesh_int_tag_test(), mesh_struct_tag_test(), mesh_tag_delete_test(), normals_test(), PushParMeshIntoMoab(), query_elem_to_vert(), query_vert_to_elem(), ray_test(), root_set_test(), ScdMesh(), ScdMeshF90(), smooth_test(), split_quads_test(), split_test(), split_test_across(), tag_get_set_test(), tag_info_test(), tag_iterate(), test_load(), test_step_iter(), test_tag_iterate(), test_tags_retrieval(), topology_adjacencies_test(), topology_adjacency_test(), topology_dimension_test(), vertex_coordinates_test(), vertex_tag_test(), volume_test(), and moab::TempestOnlineMap::WriteHDF5MapFile().
1.7.6.1