MOAB: Mesh Oriented datABase  (version 5.5.0)
Functions | Variables
MOAB_iMesh_unit_tests.cpp File Reference
#include "TestRunner.hpp"
#include "iMesh.h"
#include "MBiMesh.hpp"
#include "moab/Core.hpp"
#include <algorithm>
+ Include dependency graph for MOAB_iMesh_unit_tests.cpp:

Go to the source code of this file.

Functions

iMesh_Instance create_mesh ()
 
void test_getEntArrAdj_conn ()
 
void test_getEntArrAdj_vertex ()
 
void test_getEntArrAdj_up ()
 
void test_getEntArrAdj_down ()
 
void test_getEntArrAdj_invalid_size ()
 
void test_getEntArrAdj_none ()
 
void test_existinterface ()
 
void test_tags_retrieval ()
 
void test_invalid_parallel_option ()
 
int main (int argc, char *argv[])
 
static void HEX_VERTS (int i, int j, int k, iBase_EntityHandle conn[8])
 
static void QUAD_VERTS (int f, int i, int j, iBase_EntityHandle conn[4])
 

Variables

const int INTERVALS = 2
 
iBase_EntityHandle VERTS [INTERVALS+1][INTERVALS+1][INTERVALS+1]
 
iBase_EntityHandle HEXES [INTERVALS][INTERVALS][INTERVALS]
 
iBase_EntityHandle FACES [6][INTERVALS][INTERVALS]
 

Function Documentation

◆ create_mesh()

iMesh_Instance create_mesh ( )

Definition at line 98 of file MOAB_iMesh_unit_tests.cpp.

99 {
100  static iMesh_Instance instance = 0;
101  if( instance ) return instance;
102 
103  int err;
104  iMesh_Instance tmp;
105  iMesh_newMesh( 0, &tmp, &err, 0 );
106  CHECK_EQUAL( iBase_SUCCESS, err );
107 
108  for( int i = 0; i < INTERVALS + 1; ++i )
109  for( int j = 0; j < INTERVALS + 1; ++j )
110  for( int k = 0; k < INTERVALS + 1; ++k )
111  {
112  iMesh_createVtx( tmp, i, j, k, &VERTS[i][j][k], &err );
113  CHECK_EQUAL( iBase_SUCCESS, err );
114  }
115 
116  int status;
117  iBase_EntityHandle conn[8];
118  for( int i = 0; i < INTERVALS; ++i )
119  for( int j = 0; j < INTERVALS; ++j )
120  for( int k = 0; k < INTERVALS; ++k )
121  {
122  HEX_VERTS( i, j, k, conn );
123  iMesh_createEnt( tmp, iMesh_HEXAHEDRON, conn, 8, &HEXES[i][j][k], &status, &err );
124  CHECK_EQUAL( iBase_SUCCESS, err );
125  CHECK_EQUAL( iBase_NEW, status );
126  }
127 
128  for( int f = 0; f < 6; ++f )
129  for( int i = 0; i < INTERVALS; ++i )
130  for( int j = 0; j < INTERVALS; ++j )
131  {
132  QUAD_VERTS( f, i, j, conn );
133  iMesh_createEnt( tmp, iMesh_QUADRILATERAL, conn, 4, &FACES[f][i][j], &status, &err );
134  CHECK_EQUAL( iBase_SUCCESS, err );
135  }
136 
137  return ( instance = tmp );
138 }

References CHECK_EQUAL, FACES, HEX_VERTS(), HEXES, iBase_NEW, iBase_SUCCESS, iMesh_createEnt, iMesh_createVtx, iMesh_HEXAHEDRON, iMesh_newMesh, iMesh_QUADRILATERAL, INTERVALS, QUAD_VERTS(), and VERTS.

Referenced by main(), test_getEntArrAdj_conn(), test_getEntArrAdj_down(), test_getEntArrAdj_invalid_size(), test_getEntArrAdj_none(), test_getEntArrAdj_up(), and test_getEntArrAdj_vertex().

◆ HEX_VERTS()

static void HEX_VERTS ( int  i,
int  j,
int  k,
iBase_EntityHandle  conn[8] 
)
static

Definition at line 56 of file MOAB_iMesh_unit_tests.cpp.

57 {
58  conn[0] = VERTS[i][j][k];
59  conn[1] = VERTS[i + 1][j][k];
60  conn[2] = VERTS[i + 1][j + 1][k];
61  conn[3] = VERTS[i][j + 1][k];
62  conn[4] = VERTS[i][j][k + 1];
63  conn[5] = VERTS[i + 1][j][k + 1];
64  conn[6] = VERTS[i + 1][j + 1][k + 1];
65  conn[7] = VERTS[i][j + 1][k + 1];
66 }

References VERTS.

Referenced by create_mesh(), and test_getEntArrAdj_conn().

◆ main()

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

Definition at line 19 of file MOAB_iMesh_unit_tests.cpp.

20 {
21  REGISTER_TEST( test_getEntArrAdj_conn );
22  REGISTER_TEST( test_getEntArrAdj_vertex );
23  REGISTER_TEST( test_getEntArrAdj_up );
24  REGISTER_TEST( test_getEntArrAdj_down );
25  REGISTER_TEST( test_getEntArrAdj_invalid_size );
26  REGISTER_TEST( test_getEntArrAdj_none );
27  REGISTER_TEST( test_existinterface );
28 #ifdef MOAB_HAVE_HDF5
29  REGISTER_TEST( test_tags_retrieval );
30 #endif
31 #ifndef MOAB_HAVE_MPI
32  REGISTER_TEST( test_invalid_parallel_option );
33 #endif
34  int result = RUN_TESTS( argc, argv );
35 
36  // Delete the static iMesh instance defined in create_mesh()
37  iMesh_Instance mesh = create_mesh();
38  int err;
39  iMesh_dtor( mesh, &err );
40  CHECK_EQUAL( iBase_SUCCESS, err );
41 
42  return result;
43 }

References CHECK_EQUAL, create_mesh(), iBase_SUCCESS, iMesh_dtor, mesh, REGISTER_TEST, RUN_TESTS, test_existinterface(), test_getEntArrAdj_conn(), test_getEntArrAdj_down(), test_getEntArrAdj_invalid_size(), test_getEntArrAdj_none(), test_getEntArrAdj_up(), test_getEntArrAdj_vertex(), test_invalid_parallel_option(), and test_tags_retrieval().

◆ QUAD_VERTS()

static void QUAD_VERTS ( int  f,
int  i,
int  j,
iBase_EntityHandle  conn[4] 
)
static

Definition at line 68 of file MOAB_iMesh_unit_tests.cpp.

69 {
70  switch( f )
71  {
72  case 0:
73  case 2:
74  conn[0] = VERTS[i][INTERVALS * ( f / 2 )][j];
75  conn[1] = VERTS[i + 1][INTERVALS * ( f / 2 )][j];
76  conn[2] = VERTS[i + 1][INTERVALS * ( f / 2 )][j + 1];
77  conn[3] = VERTS[i][INTERVALS * ( f / 2 )][j + 1];
78  break;
79  case 1:
80  case 3:
81  conn[0] = VERTS[INTERVALS * ( 1 / f )][i][j];
82  conn[1] = VERTS[INTERVALS * ( 1 / f )][i + 1][j];
83  conn[2] = VERTS[INTERVALS * ( 1 / f )][i + 1][j + 1];
84  conn[3] = VERTS[INTERVALS * ( 1 / f )][i][j + 1];
85  break;
86  case 4:
87  case 5:
88  conn[0] = VERTS[i][j][INTERVALS * ( f - 4 )];
89  conn[1] = VERTS[i + 1][j][INTERVALS * ( f - 4 )];
90  conn[2] = VERTS[i + 1][j + 1][INTERVALS * ( f - 4 )];
91  conn[3] = VERTS[i][j + 1][INTERVALS * ( f - 4 )];
92  break;
93  default:
94  CHECK( false );
95  }
96 }

References CHECK, INTERVALS, and VERTS.

Referenced by create_mesh(), and test_getEntArrAdj_conn().

◆ test_existinterface()

void test_existinterface ( )

Definition at line 402 of file MOAB_iMesh_unit_tests.cpp.

403 {
404  // test construction of an imesh instance from a core instance
405  moab::Core* core = new moab::Core();
406  MBiMesh* mesh = new MBiMesh( core );
407  iMesh_Instance imesh = reinterpret_cast< iMesh_Instance >( mesh );
408 
409  // make sure we can call imesh functions
410  int dim, err;
411  iMesh_getGeometricDimension( imesh, &dim, &err );
412  CHECK_EQUAL( iBase_SUCCESS, err );
413 
414  // now make sure we can delete the instance without it deleting the MOAB instance
415  iMesh_dtor( imesh, &err );
416  CHECK_EQUAL( err, iBase_SUCCESS );
417 
418  ErrorCode rval = core->get_number_entities_by_dimension( 0, 0, dim );
419  CHECK_EQUAL( moab::MB_SUCCESS, rval );
420 
421  // finally, delete the MOAB instance
422  delete core;
423 }

References CHECK_EQUAL, dim, ErrorCode, moab::Core::get_number_entities_by_dimension(), iBase_SUCCESS, iMesh_dtor, iMesh_getGeometricDimension, MB_SUCCESS, and mesh.

Referenced by main().

◆ test_getEntArrAdj_conn()

void test_getEntArrAdj_conn ( )

Definition at line 140 of file MOAB_iMesh_unit_tests.cpp.

141 {
142  iMesh_Instance mesh = create_mesh();
143  int err;
144 
145  // test hex vertices
146  for( int i = 0; i < INTERVALS; ++i )
147  {
148  for( int j = 0; j < INTERVALS; ++j )
149  {
150  iBase_EntityHandle adj[8 * INTERVALS];
151  int off[INTERVALS + 1];
152  int adj_alloc = sizeof( adj ) / sizeof( adj[0] );
153  int off_alloc = sizeof( off ) / sizeof( off[0] );
154  int adj_size = -1, off_size = -1;
155  iBase_EntityHandle* adj_ptr = adj;
156  int* off_ptr = off;
157  iMesh_getEntArrAdj( mesh, HEXES[i][j], INTERVALS, iBase_VERTEX, &adj_ptr, &adj_alloc, &adj_size, &off_ptr,
158  &off_alloc, &off_size, &err );
159  CHECK_EQUAL( &adj[0], adj_ptr );
160  CHECK_EQUAL( &off[0], off_ptr );
161  CHECK_EQUAL( iBase_SUCCESS, err );
162  CHECK_EQUAL( 8 * INTERVALS, adj_size );
163  CHECK_EQUAL( 8 * INTERVALS, adj_alloc );
164  CHECK_EQUAL( INTERVALS + 1, off_size );
165  CHECK_EQUAL( INTERVALS + 1, off_alloc );
166  for( int k = 0; k < INTERVALS; ++k )
167  {
168  CHECK_EQUAL( 8 * k, off[k] );
169  iBase_EntityHandle conn[8];
170  HEX_VERTS( i, j, k, conn );
171  CHECK_ARRAYS_EQUAL( conn, 8, adj + off[k], off[k + 1] - off[k] );
172  }
173  }
174  }
175 
176  // test quad vertices for one side of mesh
177  const int f = 0;
178  for( int i = 0; i < INTERVALS; ++i )
179  {
180  iBase_EntityHandle adj[4 * INTERVALS];
181  int off[INTERVALS + 1];
182  int adj_alloc = sizeof( adj ) / sizeof( adj[0] );
183  int off_alloc = sizeof( off ) / sizeof( off[0] );
184  int adj_size = -1, off_size = -1;
185  iBase_EntityHandle* adj_ptr = adj;
186  int* off_ptr = off;
187  iMesh_getEntArrAdj( mesh, FACES[f][i], INTERVALS, iBase_VERTEX, &adj_ptr, &adj_alloc, &adj_size, &off_ptr,
188  &off_alloc, &off_size, &err );
189  CHECK_EQUAL( &adj[0], adj_ptr );
190  CHECK_EQUAL( &off[0], off_ptr );
191  CHECK_EQUAL( iBase_SUCCESS, err );
192  CHECK_EQUAL( 4 * INTERVALS, adj_size );
193  CHECK_EQUAL( 4 * INTERVALS, adj_alloc );
194  CHECK_EQUAL( INTERVALS + 1, off_size );
195  CHECK_EQUAL( INTERVALS + 1, off_alloc );
196  for( int k = 0; k < INTERVALS; ++k )
197  {
198  CHECK_EQUAL( 4 * k, off[k] );
199  iBase_EntityHandle conn[4];
200  QUAD_VERTS( f, i, k, conn );
201  CHECK_ARRAYS_EQUAL( conn, 4, adj + off[k], off[k + 1] - off[k] );
202  }
203  }
204 }

References CHECK_ARRAYS_EQUAL, CHECK_EQUAL, create_mesh(), FACES, HEX_VERTS(), HEXES, iBase_SUCCESS, iBase_VERTEX, iMesh_getEntArrAdj, INTERVALS, mesh, and QUAD_VERTS().

Referenced by main().

◆ test_getEntArrAdj_down()

void test_getEntArrAdj_down ( )

Definition at line 274 of file MOAB_iMesh_unit_tests.cpp.

275 {
276  iMesh_Instance mesh = create_mesh();
277  int err;
278 
279  // get quads adjacent to a edge-row of hexes
280  iBase_EntityHandle* adj = 0;
281  int* off = 0;
282  int adj_alloc = 0, off_alloc = 0;
283  int adj_size = -1, off_size = -1;
284  iMesh_getEntArrAdj( mesh, HEXES[0][0], INTERVALS, iBase_FACE, &adj, &adj_alloc, &adj_size, &off, &off_alloc,
285  &off_size, &err );
286  CHECK_EQUAL( iBase_SUCCESS, err );
287  CHECK( 0 != adj );
288  CHECK( 0 != off );
289  CHECK_EQUAL( 2 * INTERVALS + 2, adj_size ); // corner hexes adj to 3 faces, others adj to 2
290  CHECK_EQUAL( INTERVALS + 1, off_size ); // one more than number of input handles
291  CHECK( adj_alloc >= adj_size );
292  CHECK( off_alloc >= off_size );
293 
294  // first (corner) hex should have three adjacent faces
295  CHECK_EQUAL( 3, off[1] - off[0] );
296  iBase_EntityHandle exp[3] = { FACES[0][0][0], FACES[3][0][0], FACES[4][0][0] };
297  iBase_EntityHandle act[3];
298  std::copy( adj + off[0], adj + off[1], act );
299  std::sort( exp, exp + 3 );
300  std::sort( act, act + 3 );
301  CHECK_ARRAYS_EQUAL( exp, 3, act, 3 );
302 
303  // last (corner) hex should have three adjacent faces
304  CHECK_EQUAL( 3, off[INTERVALS] - off[INTERVALS - 1] );
305  iBase_EntityHandle exp2[3] = { FACES[0][0][INTERVALS - 1], FACES[3][0][INTERVALS - 1], FACES[5][0][0] };
306  std::copy( adj + off[INTERVALS - 1], adj + off[INTERVALS], act );
307  std::sort( exp2, exp2 + 3 );
308  std::sort( act, act + 3 );
309  CHECK_ARRAYS_EQUAL( exp2, 3, act, 3 );
310 
311  // all middle hexes should have two adjacent faces
312  // FixME: This loop is never executed (INTERVALS is 2)
313  /*
314  for (int i = 1; i < INTERVALS-1; ++i) {
315  iBase_EntityHandle e1, e2, a1, a2;
316  e1 = FACES[0][0][i];
317  e2 = FACES[3][0][i];
318  if (e1 > e2) std::swap(e1,e2);
319 
320  CHECK_EQUAL( 2, off[i+1] - off[i] );
321  a1 = adj[off[i] ];
322  a2 = adj[off[i]+1];
323  if (a1 > a2) std::swap(a1,a2);
324 
325  CHECK_EQUAL( e1, a1 );
326  CHECK_EQUAL( e2, a2 );
327  }
328  */
329 
330  free( adj );
331  free( off );
332 }

References CHECK, CHECK_ARRAYS_EQUAL, CHECK_EQUAL, create_mesh(), FACES, HEXES, iBase_FACE, iBase_SUCCESS, iMesh_getEntArrAdj, INTERVALS, and mesh.

Referenced by main().

◆ test_getEntArrAdj_invalid_size()

void test_getEntArrAdj_invalid_size ( )

Definition at line 334 of file MOAB_iMesh_unit_tests.cpp.

335 {
336  iMesh_Instance mesh = create_mesh();
337  int err = -1;
338 
339  const int SPECIAL1 = 0xDeadBeef;
340  const int SPECIAL2 = 0xCafe5;
341  const int SPECIAL3 = 0xbabb1e;
342 
343  // test a downward query
344  volatile int marker1 = SPECIAL1;
345  iBase_EntityHandle adj1[8 * INTERVALS - 1]; // one too small
346  volatile int marker2 = SPECIAL2;
347  int off1[INTERVALS + 1];
348  int adj1_alloc = sizeof( adj1 ) / sizeof( adj1[0] );
349  int off1_alloc = sizeof( off1 ) / sizeof( off1[0] );
350  int adj_size, off_size;
351  iBase_EntityHandle* adj_ptr = adj1;
352  int* off_ptr = off1;
353  iMesh_getEntArrAdj( mesh, HEXES[0][0], INTERVALS, iBase_VERTEX, &adj_ptr, &adj1_alloc, &adj_size, &off_ptr,
354  &off1_alloc, &off_size, &err );
355  CHECK_EQUAL( &adj1[0], adj_ptr );
356  CHECK_EQUAL( &off1[0], off_ptr );
357  // first ensure no stack corruption from writing off end of array
358  CHECK_EQUAL( SPECIAL1, marker1 );
359  CHECK_EQUAL( SPECIAL2, marker2 );
360  // now verify that it correctly failed
361  CHECK_EQUAL( iBase_BAD_ARRAY_SIZE, err );
362 
363  // now test an upwards query
364  volatile int marker3 = SPECIAL3;
365  int off2[INTERVALS];
366  volatile int marker4 = SPECIAL1;
367  int off2_alloc = sizeof( off2 ) / sizeof( off2[0] );
368  err = iBase_SUCCESS;
369  adj_ptr = adj1;
370  off_ptr = off2;
371  iMesh_getEntArrAdj( mesh, VERTS[0][0], INTERVALS + 1, iBase_REGION, &adj_ptr, &adj1_alloc, &adj_size, &off_ptr,
372  &off2_alloc, &off_size, &err );
373  // first ensure no stack corruption from writing off end of array
374  CHECK_EQUAL( &adj1[0], adj_ptr );
375  CHECK_EQUAL( &off2[0], off_ptr );
376  CHECK_EQUAL( SPECIAL3, marker3 );
377  CHECK_EQUAL( SPECIAL1, marker4 );
378  // now verify that it correctly failed
379  CHECK_EQUAL( iBase_BAD_ARRAY_SIZE, err );
380 }

References CHECK_EQUAL, create_mesh(), HEXES, iBase_BAD_ARRAY_SIZE, iBase_REGION, iBase_SUCCESS, iBase_VERTEX, iMesh_getEntArrAdj, INTERVALS, mesh, and VERTS.

Referenced by main().

◆ test_getEntArrAdj_none()

void test_getEntArrAdj_none ( )

Definition at line 382 of file MOAB_iMesh_unit_tests.cpp.

383 {
384  iMesh_Instance mesh = create_mesh();
385  int err = -1;
386 
387  iBase_EntityHandle* adj = 0;
388  int* off = 0;
389  int adj_alloc = 0, off_alloc = 0;
390  int adj_size = -1, off_size = -1;
391  iMesh_getEntArrAdj( mesh, NULL, 0, iBase_REGION, &adj, &adj_alloc, &adj_size, &off, &off_alloc, &off_size, &err );
392  CHECK_EQUAL( iBase_SUCCESS, err );
393  CHECK_EQUAL( 0, adj_alloc );
394  CHECK_EQUAL( 0, adj_size );
395  CHECK_EQUAL( 1, off_size );
396  CHECK( off_alloc >= 1 );
397  CHECK_EQUAL( 0, off[0] );
398 
399  free( off );
400 }

References CHECK, CHECK_EQUAL, create_mesh(), iBase_REGION, iBase_SUCCESS, iMesh_getEntArrAdj, and mesh.

Referenced by main().

◆ test_getEntArrAdj_up()

void test_getEntArrAdj_up ( )

Definition at line 244 of file MOAB_iMesh_unit_tests.cpp.

245 {
246  iMesh_Instance mesh = create_mesh();
247  int err;
248 
249  // get hexes adjacent to a row of faces in the z=0 plane
250  iBase_EntityHandle* adj = 0;
251  int* off = 0;
252  int adj_alloc = 0, off_alloc = 0;
253  int adj_size = -1, off_size = -1;
254  iMesh_getEntArrAdj( mesh, FACES[4][0], INTERVALS, iBase_REGION, &adj, &adj_alloc, &adj_size, &off, &off_alloc,
255  &off_size, &err );
256  CHECK_EQUAL( iBase_SUCCESS, err );
257  CHECK( 0 != adj );
258  CHECK( 0 != off );
259  CHECK_EQUAL( INTERVALS, adj_size ); // one hex adjacent to each skin face
260  CHECK_EQUAL( INTERVALS + 1, off_size ); // one more than number of input handles
261  CHECK( adj_alloc >= adj_size );
262  CHECK( off_alloc >= off_size );
263 
264  for( int i = 0; i < INTERVALS; ++i )
265  {
266  CHECK_EQUAL( 1, off[i + 1] - off[i] );
267  CHECK_EQUAL( HEXES[0][i][0], adj[off[i]] );
268  }
269 
270  free( adj );
271  free( off );
272 }

References CHECK, CHECK_EQUAL, create_mesh(), FACES, HEXES, iBase_REGION, iBase_SUCCESS, iMesh_getEntArrAdj, INTERVALS, and mesh.

Referenced by main().

◆ test_getEntArrAdj_vertex()

void test_getEntArrAdj_vertex ( )

Definition at line 206 of file MOAB_iMesh_unit_tests.cpp.

207 {
208  iMesh_Instance mesh = create_mesh();
209  int err;
210 
211  // get hexes adjacent to row of vertices at x=0,y=0;
212  iBase_EntityHandle* adj = 0;
213  int* off = 0;
214  int adj_alloc = 0, off_alloc = 0;
215  int adj_size = -1, off_size = -1;
216  iMesh_getEntArrAdj( mesh, VERTS[0][0], INTERVALS + 1, iBase_REGION, &adj, &adj_alloc, &adj_size, &off, &off_alloc,
217  &off_size, &err );
218  CHECK_EQUAL( iBase_SUCCESS, err );
219  CHECK( 0 != adj );
220  CHECK( 0 != off );
221  CHECK_EQUAL( 2 * INTERVALS,
222  adj_size ); // INTERVALS+1 verts, end ones with one hex, others with two
223  CHECK_EQUAL( INTERVALS + 2, off_size ); // one more than number of input handles
224  CHECK( adj_alloc >= adj_size );
225  CHECK( off_alloc >= off_size );
226 
227  // first and last vertices should have one adjacent hex
228  CHECK_EQUAL( 1, off[1] - off[0] );
229  CHECK_EQUAL( HEXES[0][0][0], adj[off[0]] );
230  CHECK_EQUAL( 1, off[INTERVALS + 1] - off[INTERVALS] );
231  CHECK_EQUAL( HEXES[0][0][INTERVALS - 1], adj[off[INTERVALS]] );
232  // middle ones should have two adjacent hexes
233  for( int i = 1; i < INTERVALS; ++i )
234  {
235  CHECK_EQUAL( 2, off[i + 1] - off[i] );
236  CHECK_EQUAL( HEXES[0][0][i - 1], adj[off[i]] );
237  CHECK_EQUAL( HEXES[0][0][i], adj[off[i] + 1] );
238  }
239 
240  free( adj );
241  free( off );
242 }

References CHECK, CHECK_EQUAL, create_mesh(), HEXES, iBase_REGION, iBase_SUCCESS, iMesh_getEntArrAdj, INTERVALS, mesh, and VERTS.

Referenced by main().

◆ test_invalid_parallel_option()

void test_invalid_parallel_option ( )

Definition at line 477 of file MOAB_iMesh_unit_tests.cpp.

478 {
479  iMesh_Instance mesh;
480  int err;
481  iMesh_newMesh( "moab:PARALLEL", &mesh, &err, 13 );
482  CHECK_EQUAL( iBase_NOT_SUPPORTED, err );
483 
484  iMesh_dtor( mesh, &err );
485  CHECK_EQUAL( iBase_SUCCESS, err );
486 }

References CHECK_EQUAL, iBase_NOT_SUPPORTED, iBase_SUCCESS, iMesh_dtor, iMesh_newMesh, and mesh.

Referenced by main().

◆ test_tags_retrieval()

void test_tags_retrieval ( )

Definition at line 425 of file MOAB_iMesh_unit_tests.cpp.

426 {
427  iMesh_Instance mesh;
428  int err;
429  iMesh_newMesh( "", &mesh, &err, 0 );
430  CHECK_EQUAL( iBase_SUCCESS, err );
431 
432  iBase_EntitySetHandle root_set;
433  iMesh_getRootSet( mesh, &root_set, &err );
434  CHECK_EQUAL( iBase_SUCCESS, err );
435 
436  // open a file with var len tags (sense tags)
437  // they should be filtered out
438  std::string filename = STRINGIFY( MESHDIR ) "/PB.h5m";
439 
440  iMesh_load( mesh, root_set, filename.c_str(), NULL, &err, filename.length(), 0 );
441  CHECK_EQUAL( iBase_SUCCESS, err );
442 
443  iBase_EntitySetHandle* contained_set_handles = NULL;
444  int contained_set_handles_allocated = 0;
445  int contained_set_handles_size;
446  // get all entity sets
447  iMesh_getEntSets( mesh, root_set, 1, &contained_set_handles, &contained_set_handles_allocated,
448  &contained_set_handles_size, &err );
449  CHECK_EQUAL( iBase_SUCCESS, err );
450  // get tags for all sets
451  for( int i = 0; i < contained_set_handles_size; i++ )
452  {
453  iBase_TagHandle* tag_handles = NULL;
454  int tag_handles_allocated = 0;
455  int tag_handles_size;
456  iMesh_getAllEntSetTags( mesh, contained_set_handles[i], &tag_handles, &tag_handles_allocated, &tag_handles_size,
457  &err );
458  CHECK_EQUAL( iBase_SUCCESS, err );
459 
460  for( int j = 0; j < tag_handles_size; j++ )
461  {
462  int tagSize;
463  iMesh_getTagSizeValues( mesh, tag_handles[j], &tagSize, &err );
464  CHECK_EQUAL( iBase_SUCCESS, err );
465  }
466  free( tag_handles );
467  }
468  free( contained_set_handles );
469 
470  // Delete the iMesh instance
471  iMesh_dtor( mesh, &err );
472  CHECK_EQUAL( iBase_SUCCESS, err );
473 
474  return;
475 }

References CHECK_EQUAL, filename, iBase_SUCCESS, iMesh_dtor, iMesh_getAllEntSetTags, iMesh_getEntSets, iMesh_getRootSet, iMesh_getTagSizeValues, iMesh_load, iMesh_newMesh, mesh, root_set, and STRINGIFY.

Referenced by main().

Variable Documentation

◆ FACES

iBase_EntityHandle FACES[6][INTERVALS][INTERVALS]

Definition at line 54 of file MOAB_iMesh_unit_tests.cpp.

Referenced by create_mesh(), test_getEntArrAdj_conn(), test_getEntArrAdj_down(), and test_getEntArrAdj_up().

◆ HEXES

iBase_EntityHandle HEXES[INTERVALS][INTERVALS][INTERVALS]

Definition at line 53 of file MOAB_iMesh_unit_tests.cpp.

Referenced by create_mesh(), test_getEntArrAdj_conn(), test_getEntArrAdj_down(), test_getEntArrAdj_invalid_size(), test_getEntArrAdj_up(), and test_getEntArrAdj_vertex().

◆ INTERVALS

const int INTERVALS = 2

Definition at line 51 of file MOAB_iMesh_unit_tests.cpp.

Referenced by create_mesh(), QUAD_VERTS(), test_getEntArrAdj_conn(), test_getEntArrAdj_down(), test_getEntArrAdj_invalid_size(), test_getEntArrAdj_up(), and test_getEntArrAdj_vertex().

◆ VERTS

iBase_EntityHandle VERTS[INTERVALS+1][INTERVALS+1][INTERVALS+1]

Definition at line 52 of file MOAB_iMesh_unit_tests.cpp.

Referenced by create_mesh(), HEX_VERTS(), QUAD_VERTS(), test_getEntArrAdj_invalid_size(), and test_getEntArrAdj_vertex().