testc_cbind.cpp File Reference

#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.

Classes
struct	TagStruct

Macros
#define	FALSE   0
#define	TRUE   1
#define	DEFAULT_TEST_FILE   brick.vtk
#define	DEFAULT_INPUT_FILE   STRINGIFY( DEFAULT_TEST_FILE )
#define	ASSERT(COND)
#define	CHK(err)
#define	TEST_ERROR_CODE(A, B)

Functions
void	PRINT_ASSERT_FAILURE (const char *cond, const char *file, int line)
void	handle_error_code (const int result, int *number_failed, int *, int *number_successful)
int	load_mesh_test (const char *filename, iMesh_Instance mesh)
int	error_code_test (iMesh_Instance)
int	topology_dimension_test (iMesh_Instance mesh)
int	topology_adjacency_test (iMesh_Instance mesh)
int	qsort_comp_handles (const void *h1, const void *h2)
int	entity_connectivity_test (iMesh_Instance mesh)
int	check_esets (iMesh_Instance mesh, const int num_sets)
int	entity_sets_subtest (iMesh_Instance mesh, int is_list, int)
int	entity_sets_test (iMesh_Instance mesh)
int	vertex_coordinates_test (iMesh_Instance mesh)
int	tag_info_test (iMesh_Instance mesh)
int	vertex_int_tag_test (iMesh_Instance mesh, iBase_EntityHandle *verts, int, iBase_TagHandle *int_tag)
int	vertex_double_tag_test (iMesh_Instance mesh, iBase_EntityHandle *verts, int, iBase_TagHandle *double_tag)
int	vertex_struct_tag_test (iMesh_Instance mesh, iBase_EntityHandle *verts, int, iBase_TagHandle *struct_tag)
int	vertex_tag_delete_test (iMesh_Instance mesh, iBase_EntityHandle *verts, int)
int	vertex_tag_test (iMesh_Instance mesh)
int	entityset_int_tag_test (iMesh_Instance mesh, iBase_EntitySetHandle *sets, int sets_size, iBase_TagHandle *int_tag)
int	entityset_double_tag_test (iMesh_Instance mesh, iBase_EntitySetHandle *sets, int sets_size, iBase_TagHandle *double_tag)
int	entityset_struct_tag_test (iMesh_Instance mesh, iBase_EntitySetHandle *, int, iBase_TagHandle *struct_tag)
int	entityset_tag_delete_test (iMesh_Instance mesh, iBase_EntitySetHandle *sets, int sets_size)
int	entityset_tag_test (iMesh_Instance mesh)
int	mesh_int_tag_test (iMesh_Instance mesh, iBase_TagHandle *int_tag)
int	mesh_double_tag_test (iMesh_Instance mesh, iBase_TagHandle *double_tag)
int	mesh_struct_tag_test (iMesh_Instance mesh, iBase_TagHandle *struct_tag)
int	mesh_tag_delete_test (iMesh_Instance mesh)
int	mesh_tag_test (iMesh_Instance mesh)
int	set_remove_contained_regression (iMesh_Instance mesh)
int	all_adjacency_regression (iMesh_Instance mesh)
static int	ordered_set_regression (iMesh_Instance mesh)
int	array_allocation (iMesh_Instance mesh)
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)
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)
int	test_iterator_common (const char *info, iMesh_Instance mesh, iBase_EntitySetHandle set, int array_size, enum iBase_EntityType type, enum iMesh_EntityTopology topo)
int	test_iterator (iMesh_Instance mesh)
int	main (int argc, char *argv[])

Variables
enum iBase_ErrorType	iBase_ERROR_MAP [MB_FAILURE+1]
static bool	assert_pass
static iBase_EntitySetHandle	root_set

Macro Definition Documentation

ASSERT

#define ASSERT

(

COND

)

Value:

 assert_pass = true; \
 if( !( COND ) ) \
 { \
 PRINT_ASSERT_FAILURE( #COND, __FILE__, __LINE__ ); \
 assert_pass = false; \
 }

Definition at line 82 of file testc_cbind.cpp.

CHK

#define CHK

(

err

)

Value:

 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.

DEFAULT_INPUT_FILE

#define DEFAULT_INPUT_FILE   STRINGIFY( DEFAULT_TEST_FILE )

Definition at line 78 of file testc_cbind.cpp.

DEFAULT_TEST_FILE

#define DEFAULT_TEST_FILE   brick.vtk

Definition at line 71 of file testc_cbind.cpp.

FALSE

#define FALSE   0

Definition at line 68 of file testc_cbind.cpp.

TEST_ERROR_CODE

#define TEST_ERROR_CODE	(		A,
			B
	)

Value:

 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.

TRUE

#define TRUE   1

Definition at line 69 of file testc_cbind.cpp.

Function Documentation

all_adjacency_regression()

int all_adjacency_regression

(

iMesh_Instance

mesh

)

Definition at line 2659 of file testc_cbind.cpp.

{
 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;
}

References iBase_ALL_TYPES, iBase_INTERLEAVED, iBase_NEW, iBase_SUCCESS, iMesh_createEnt, iMesh_createVtxArr, iMesh_dtor, iMesh_getEntAdj, iMesh_LINE_SEGMENT, iMesh_newMesh, and mesh.

Referenced by main().

array_allocation()

int array_allocation

(

iMesh_Instance

mesh

)

Definition at line 2749 of file testc_cbind.cpp.

{
 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;
}

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, mesh, and root_set.

Referenced by main().

check_esets()

int check_esets	(	iMesh_Instance	mesh,
		const int	num_sets
	)

Test:

TSTT entity sets sub test

• Check entity sets

Definition at line 1623 of file testc_cbind.cpp.

{
 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;
}

References FALSE, iBase_SUCCESS, iMesh_getNumEntSets, mesh, root_set, and TRUE.

Referenced by entity_sets_subtest().

compare_array_iter()

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.

{
 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;
}

References iBase_FAILURE, iBase_SUCCESS, iMesh_endEntArrIter, iMesh_getNextEntArrIter, iMesh_initEntArrIter, iMesh_resetEntArrIter, and mesh.

Referenced by test_iterator_common().

compare_single_iter()

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.

{
 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;
}

References iBase_FAILURE, iBase_SUCCESS, iMesh_endEntIter, iMesh_getNextEntIter, iMesh_initEntIter, iMesh_resetEntIter, and mesh.

Referenced by test_iterator_common().

entity_connectivity_test()

int entity_connectivity_test

(

iMesh_Instance

mesh

)

Test:

TSTT EntityType Connectivity Test

• Get coordinates for all type enities

Definition at line 514 of file testc_cbind.cpp.

{
 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;
}

References ASSERT, assert_pass, entities, FALSE, iBase_ALL_TYPES, iBase_EDGE, iBase_SUCCESS, iBase_VERTEX, iMesh_ALL_TOPOLOGIES, iMesh_getAdjEntIndices, iMesh_getEntAdj, iMesh_getEntities, mesh, qsort_comp_handles(), root_set, size, and TRUE.

Referenced by main().

entity_sets_subtest()

int entity_sets_subtest	(	iMesh_Instance	mesh,
		int	is_list,
		int
	)

Definition at line 754 of file testc_cbind.cpp.

{
 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, &regions, &regions_alloc,
 &regions_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;
}

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, mesh, root_set, and TRUE.

Referenced by entity_sets_test().

entity_sets_test()

int entity_sets_test

(

iMesh_Instance

mesh

)

Test:

TSTT entity sets Test

• Check entity sets

Definition at line 1650 of file testc_cbind.cpp.

{
 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;
}

References entity_sets_subtest(), mesh, and TRUE.

Referenced by main().

entityset_double_tag_test()

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.

{
 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;
}

References FALSE, iBase_DOUBLE, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, mesh, and TRUE.

Referenced by entityset_tag_test().

entityset_int_tag_test()

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.

{
 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;
}

References FALSE, iBase_INTEGER, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, mesh, and TRUE.

Referenced by entityset_tag_test().

entityset_struct_tag_test()

int entityset_struct_tag_test	(	iMesh_Instance	mesh,
		iBase_EntitySetHandle *	,
		int	,
		iBase_TagHandle *	struct_tag
	)

Definition at line 2225 of file testc_cbind.cpp.

{
 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;
}

References FALSE, iBase_BYTES, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, mesh, root_set, TagStruct::test_double, TagStruct::test_int1, TagStruct::test_int2, and TRUE.

Referenced by entityset_tag_test().

entityset_tag_delete_test()

int entityset_tag_delete_test	(	iMesh_Instance	mesh,
		iBase_EntitySetHandle *	sets,
		int	sets_size
	)

Definition at line 2277 of file testc_cbind.cpp.

{
 /* 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;
}

References FALSE, iBase_SUCCESS, iMesh_destroyTag, iMesh_getAllEntSetTags, iMesh_rmvEntSetTag, mesh, and TRUE.

Referenced by entityset_tag_test().

entityset_tag_test()

int entityset_tag_test

(

iMesh_Instance

mesh

)

Test:

TSTT entityset tag Test

• Check entityset tags

Definition at line 2339 of file testc_cbind.cpp.

{
 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 );
}

References entityset_double_tag_test(), entityset_int_tag_test(), entityset_struct_tag_test(), entityset_tag_delete_test(), FALSE, iBase_SUCCESS, iMesh_getEntSets, mesh, and root_set.

Referenced by main().

error_code_test()

int error_code_test

(

iMesh_Instance

)

Definition at line 151 of file testc_cbind.cpp.

{
 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;
}

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().

handle_error_code()

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 )++;
 }
}

Referenced by main().

load_mesh_test()

int load_mesh_test	(	const char *	filename,
		iMesh_Instance	mesh
	)

Test:

Load Mesh

• Load a mesh file

Definition at line 129 of file testc_cbind.cpp.

{
 /* 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;
}

References FALSE, filename, iBase_SUCCESS, iMesh_load, mesh, root_set, and TRUE.

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 3093 of file testc_cbind.cpp.

{
 /* 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;
}

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().

mesh_double_tag_test()

int mesh_double_tag_test	(	iMesh_Instance	mesh,
		iBase_TagHandle *	double_tag
	)

Definition at line 2437 of file testc_cbind.cpp.

{
 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;
}

References FALSE, iBase_DOUBLE, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, mesh, root_set, and TRUE.

Referenced by mesh_tag_test().

mesh_int_tag_test()

int mesh_int_tag_test	(	iMesh_Instance	mesh,
		iBase_TagHandle *	int_tag
	)

Definition at line 2372 of file testc_cbind.cpp.

{
 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;
}

References FALSE, iBase_INTEGER, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, mesh, root_set, and TRUE.

Referenced by mesh_tag_test().

mesh_struct_tag_test()

int mesh_struct_tag_test	(	iMesh_Instance	mesh,
		iBase_TagHandle *	struct_tag
	)

Definition at line 2502 of file testc_cbind.cpp.

{
 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;
}

References FALSE, iBase_BYTES, iBase_SUCCESS, iMesh_createTag, iMesh_getEntSetData, iMesh_setEntSetData, mesh, root_set, TagStruct::test_double, TagStruct::test_int1, TagStruct::test_int2, and TRUE.

Referenced by mesh_tag_test().

mesh_tag_delete_test()

int mesh_tag_delete_test

(

iMesh_Instance

mesh

)

Definition at line 2551 of file testc_cbind.cpp.

{
 /* 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;
}

References FALSE, iBase_SUCCESS, iMesh_destroyTag, iMesh_getAllEntSetTags, iMesh_rmvEntSetTag, mesh, root_set, and TRUE.

Referenced by mesh_tag_test().

mesh_tag_test()

int mesh_tag_test

(

iMesh_Instance

mesh

)

Test:

TSTT entityset tag Test

• Check entityset tags

Definition at line 2606 of file testc_cbind.cpp.

{
 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 );
}

References mesh, mesh_double_tag_test(), mesh_int_tag_test(), mesh_struct_tag_test(), and mesh_tag_delete_test().

Referenced by main().

ordered_set_regression()

static int ordered_set_regression ( iMesh_Instance  mesh )

static

Definition at line 2711 of file testc_cbind.cpp.

{
 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;
}

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, iMesh_newMesh, and mesh.

Referenced by main().

PRINT_ASSERT_FAILURE()

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 );
}

qsort_comp_handles()

int qsort_comp_handles	(	const void *	h1,
		const void *	h2
	)

Definition at line 503 of file testc_cbind.cpp.

{
 return *(char**)h1 - *(char**)h2;
}

References h1.

Referenced by entity_connectivity_test().

set_remove_contained_regression()

int set_remove_contained_regression

(

iMesh_Instance

mesh

)

Definition at line 2624 of file testc_cbind.cpp.

{
 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;
}

References contained(), iBase_SUCCESS, iMesh_addEntSet, iMesh_createEntSet, iMesh_isEntSetContained, iMesh_rmvEntSet, and mesh.

Referenced by main().

tag_info_test()

int tag_info_test

(

iMesh_Instance

mesh

)

Test:

TSTT Tag Info test

• Tests tagCreate, tagDelete, tagGetName, tagGetSize, tagGetHandle

Definition at line 1724 of file testc_cbind.cpp.

{
 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;
}

References moab::error(), FALSE, iBase_INTEGER, iBase_SUCCESS, iMesh_createTag, iMesh_destroyTag, iMesh_getTagHandle, iMesh_getTagName, iMesh_getTagSizeBytes, mesh, and TRUE.

Referenced by vertex_tag_test().

test_iterator()

int test_iterator

(

iMesh_Instance

mesh

)

Definition at line 3027 of file testc_cbind.cpp.

{
 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;
}

References CHK, iBase_ALL_TYPES, iBase_SUCCESS, iMesh_addEntArrToSet, iMesh_ALL_TOPOLOGIES, iMesh_createEntSet, iMesh_getEntities, iMesh_getRootSet, mesh, and test_iterator_common().

Referenced by main().

test_iterator_common()

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.

{
 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;
}

References CHK, compare_array_iter(), compare_single_iter(), iMesh_getEntities, and mesh.

Referenced by test_iterator().

topology_adjacency_test()

int topology_adjacency_test

(

iMesh_Instance

mesh

)

Test:

TSTT topology adjacency Test

• Check topology information
• Check adjacency
• Get interior and exterior elements

Definition at line 229 of file testc_cbind.cpp.

{
 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, &region_offsets, &region_offsets_alloc, &region_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;
}

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, mesh, root_set, and TRUE.

Referenced by main().

topology_dimension_test()

int topology_dimension_test

(

iMesh_Instance

mesh

)

Test:

TSTT topology dimension Test

• Check 2d topology dimensions

Definition at line 170 of file testc_cbind.cpp.

{
 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;
}

References FALSE, iBase_FACE, iBase_SUCCESS, iMesh_ALL_TOPOLOGIES, iMesh_getEntArrType, iMesh_getEntities, mesh, root_set, and TRUE.

Referenced by main().

vertex_coordinates_test()

int vertex_coordinates_test

(

iMesh_Instance

mesh

)

Test:

Vertex Coordinates

• Get coordinates of vertices by 2 different methods then compare them

Definition at line 1671 of file testc_cbind.cpp.

{
 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;
}

References FALSE, iBase_INTERLEAVED, iBase_SUCCESS, iBase_VERTEX, iMesh_getDfltStorage, iMesh_getEntities, iMesh_getVtxArrCoords, iMesh_POINT, mesh, root_set, and TRUE.

Referenced by main().

vertex_double_tag_test()

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.

{
 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;
}

References FALSE, iBase_DOUBLE, iBase_SUCCESS, iMesh_createTag, iMesh_getArrData, iMesh_setArrData, mesh, and TRUE.

Referenced by vertex_tag_test().

vertex_int_tag_test()

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.

{
 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;
}

References FALSE, iBase_INTEGER, iBase_SUCCESS, iMesh_createTag, iMesh_getArrData, iMesh_setArrData, mesh, and TRUE.

Referenced by vertex_tag_test().

vertex_struct_tag_test()

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.

{
 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;
}

References FALSE, iBase_BYTES, iBase_SUCCESS, iMesh_createTag, iMesh_getArrData, iMesh_setArrData, mesh, TagStruct::test_double, TagStruct::test_int1, TagStruct::test_int2, and TRUE.

Referenced by vertex_tag_test().

vertex_tag_delete_test()

int vertex_tag_delete_test	(	iMesh_Instance	mesh,
		iBase_EntityHandle *	verts,
		int
	)

Definition at line 2004 of file testc_cbind.cpp.

{
 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;
}

References FALSE, iBase_SUCCESS, iMesh_destroyTag, iMesh_getAllTags, iMesh_rmvArrTag, mesh, and TRUE.

Referenced by vertex_tag_test().

vertex_tag_test()

int vertex_tag_test

(

iMesh_Instance

mesh

)

Definition at line 2056 of file testc_cbind.cpp.

{
 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 );
}

References FALSE, iBase_ALL_TYPES, iBase_SUCCESS, iMesh_getEntities, iMesh_POINT, mesh, 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().

Variable Documentation

assert_pass

bool assert_pass

static

Definition at line 81 of file testc_cbind.cpp.

Referenced by entity_connectivity_test().

iBase_ERROR_MAP

enum iBase_ErrorType iBase_ERROR_MAP[MB_FAILURE+1]

extern

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().

root_set

iBase_EntitySetHandle root_set

static

Definition at line 105 of file testc_cbind.cpp.

Referenced by array_allocation(), check_esets(), check_ray_intersect_sets(), check_ray_intersect_tris(), create_mesh(), do_closest_point_test(), do_ray_fire_test(), entity_connectivity_test(), entity_sets_subtest(), entityset_struct_tag_test(), entityset_tag_test(), FBiGeom_getRootSet(), gentityset_test(), geometry_evaluation_test(), get_imesh_mesh(), get_itaps_domain(), moab::Coupler::get_matching_entities(), moab::FBEngine::getRootSet(), gLoad_test(), iMesh_getRootSet(), load_mesh_test(), main(), mesh_double_tag_test(), mesh_int_tag_test(), mesh_struct_tag_test(), mesh_tag_delete_test(), moab::Coupler::normalize_mesh(), moab::Coupler::normalize_subset(), normals_test(), query_elem_to_vert(), query_vert_to_elem(), moab::OrientedBoxTreeTool::ray_intersect_boxes(), moab::OrientedBoxTreeTool::ray_intersect_sets(), moab::OrientedBoxTreeTool::ray_intersect_triangles(), ray_test(), root_set_test(), smooth_test(), split_quads_test(), split_test(), split_test_across(), tag_get_set_test(), tag_info_test(), 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().