Branch data Line data Source code
1 : : #include "TestRunner.hpp"
2 : : #include "iMesh.h"
3 : : #include "MBiMesh.hpp"
4 : : #include "moab/Core.hpp"
5 : : #include <algorithm>
6 : :
7 : : iMesh_Instance create_mesh();
8 : :
9 : : void test_getEntArrAdj_conn();
10 : : void test_getEntArrAdj_vertex();
11 : : void test_getEntArrAdj_up();
12 : : void test_getEntArrAdj_down();
13 : : void test_getEntArrAdj_invalid_size();
14 : : void test_getEntArrAdj_none();
15 : : void test_existinterface();
16 : : void test_tags_retrieval();
17 : : void test_invalid_parallel_option();
18 : :
19 : 1 : int main( int argc, char* argv[] )
20 : : {
21 [ + - ]: 1 : REGISTER_TEST( test_getEntArrAdj_conn );
22 [ + - ]: 1 : REGISTER_TEST( test_getEntArrAdj_vertex );
23 [ + - ]: 1 : REGISTER_TEST( test_getEntArrAdj_up );
24 [ + - ]: 1 : REGISTER_TEST( test_getEntArrAdj_down );
25 [ + - ]: 1 : REGISTER_TEST( test_getEntArrAdj_invalid_size );
26 [ + - ]: 1 : REGISTER_TEST( test_getEntArrAdj_none );
27 [ + - ]: 1 : REGISTER_TEST( test_existinterface );
28 : : #ifdef MOAB_HAVE_HDF5
29 [ + - ]: 1 : REGISTER_TEST( test_tags_retrieval );
30 : : #endif
31 : : #ifndef MOAB_HAVE_MPI
32 : : REGISTER_TEST( test_invalid_parallel_option );
33 : : #endif
34 [ + - ]: 1 : int result = RUN_TESTS( argc, argv );
35 : :
36 : : // Delete the static iMesh instance defined in create_mesh()
37 [ + - ]: 1 : iMesh_Instance mesh = create_mesh();
38 : : int err;
39 [ + - ]: 1 : iMesh_dtor( mesh, &err );
40 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
41 : :
42 : 1 : return result;
43 : : }
44 : :
45 : : // INTERVAL x INTERVAL x INTERVAL regular hex mesh with skin faces.
46 : : // Vertices are located at even coordinate
47 : : // values and adjacent vertices are separated by one unit. The entire
48 : : // grid is in the first octant with the first vertex at the origin.
49 : : // Faces are grouped by the side of the grid that they occur in.
50 : : // The faces are { -Y, X, Y, -X, -Z, Z }.
51 : : const int INTERVALS = 2;
52 : : iBase_EntityHandle VERTS[INTERVALS + 1][INTERVALS + 1][INTERVALS + 1];
53 : : iBase_EntityHandle HEXES[INTERVALS][INTERVALS][INTERVALS];
54 : : iBase_EntityHandle FACES[6][INTERVALS][INTERVALS];
55 : :
56 : 16 : static void HEX_VERTS( int i, int j, int k, iBase_EntityHandle conn[8] )
57 : : {
58 : 16 : conn[0] = VERTS[i][j][k];
59 : 16 : conn[1] = VERTS[i + 1][j][k];
60 : 16 : conn[2] = VERTS[i + 1][j + 1][k];
61 : 16 : conn[3] = VERTS[i][j + 1][k];
62 : 16 : conn[4] = VERTS[i][j][k + 1];
63 : 16 : conn[5] = VERTS[i + 1][j][k + 1];
64 : 16 : conn[6] = VERTS[i + 1][j + 1][k + 1];
65 : 16 : conn[7] = VERTS[i][j + 1][k + 1];
66 : 16 : }
67 : :
68 : 28 : static void QUAD_VERTS( int f, int i, int j, iBase_EntityHandle conn[4] )
69 : : {
70 [ + + + - ]: 28 : switch( f )
71 : : {
72 : : case 0:
73 : : case 2:
74 : 12 : conn[0] = VERTS[i][INTERVALS * ( f / 2 )][j];
75 : 12 : conn[1] = VERTS[i + 1][INTERVALS * ( f / 2 )][j];
76 : 12 : conn[2] = VERTS[i + 1][INTERVALS * ( f / 2 )][j + 1];
77 : 12 : conn[3] = VERTS[i][INTERVALS * ( f / 2 )][j + 1];
78 : 12 : break;
79 : : case 1:
80 : : case 3:
81 : 8 : conn[0] = VERTS[INTERVALS * ( 1 / f )][i][j];
82 : 8 : conn[1] = VERTS[INTERVALS * ( 1 / f )][i + 1][j];
83 : 8 : conn[2] = VERTS[INTERVALS * ( 1 / f )][i + 1][j + 1];
84 : 8 : conn[3] = VERTS[INTERVALS * ( 1 / f )][i][j + 1];
85 : 8 : break;
86 : : case 4:
87 : : case 5:
88 : 8 : conn[0] = VERTS[i][j][INTERVALS * ( f - 4 )];
89 : 8 : conn[1] = VERTS[i + 1][j][INTERVALS * ( f - 4 )];
90 : 8 : conn[2] = VERTS[i + 1][j + 1][INTERVALS * ( f - 4 )];
91 : 8 : conn[3] = VERTS[i][j + 1][INTERVALS * ( f - 4 )];
92 : 8 : break;
93 : : default:
94 : 0 : CHECK( false );
95 : : }
96 : 28 : }
97 : :
98 : 7 : iMesh_Instance create_mesh()
99 : : {
100 : : static iMesh_Instance instance = 0;
101 [ + + ]: 7 : if( instance ) return instance;
102 : :
103 : : int err;
104 : : iMesh_Instance tmp;
105 [ + - ]: 1 : iMesh_newMesh( 0, &tmp, &err, 0 );
106 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
107 : :
108 [ + + ]: 4 : for( int i = 0; i < INTERVALS + 1; ++i )
109 [ + + ]: 12 : for( int j = 0; j < INTERVALS + 1; ++j )
110 [ + + ]: 36 : for( int k = 0; k < INTERVALS + 1; ++k )
111 : : {
112 [ + - ]: 27 : iMesh_createVtx( tmp, i, j, k, &VERTS[i][j][k], &err );
113 [ + - ]: 27 : CHECK_EQUAL( iBase_SUCCESS, err );
114 : : }
115 : :
116 : : int status;
117 : : iBase_EntityHandle conn[8];
118 [ + + ]: 3 : for( int i = 0; i < INTERVALS; ++i )
119 [ + + ]: 6 : for( int j = 0; j < INTERVALS; ++j )
120 [ + + ]: 12 : for( int k = 0; k < INTERVALS; ++k )
121 : : {
122 : 8 : HEX_VERTS( i, j, k, conn );
123 [ + - ]: 8 : iMesh_createEnt( tmp, iMesh_HEXAHEDRON, conn, 8, &HEXES[i][j][k], &status, &err );
124 [ + - ]: 8 : CHECK_EQUAL( iBase_SUCCESS, err );
125 [ + - ]: 8 : CHECK_EQUAL( iBase_NEW, status );
126 : : }
127 : :
128 [ + + ]: 7 : for( int f = 0; f < 6; ++f )
129 [ + + ]: 18 : for( int i = 0; i < INTERVALS; ++i )
130 [ + + ]: 36 : for( int j = 0; j < INTERVALS; ++j )
131 : : {
132 [ + - ]: 24 : QUAD_VERTS( f, i, j, conn );
133 [ + - ]: 24 : iMesh_createEnt( tmp, iMesh_QUADRILATERAL, conn, 4, &FACES[f][i][j], &status, &err );
134 [ + - ]: 24 : CHECK_EQUAL( iBase_SUCCESS, err );
135 : : }
136 : :
137 : 7 : return ( instance = tmp );
138 : : }
139 : :
140 : 1 : void test_getEntArrAdj_conn()
141 : : {
142 [ + - ]: 1 : iMesh_Instance mesh = create_mesh();
143 : : int err;
144 : :
145 : : // test hex vertices
146 [ + + ]: 3 : for( int i = 0; i < INTERVALS; ++i )
147 : : {
148 [ + + ]: 6 : for( int j = 0; j < INTERVALS; ++j )
149 : : {
150 : : iBase_EntityHandle adj[8 * INTERVALS];
151 : : int off[INTERVALS + 1];
152 : 4 : int adj_alloc = sizeof( adj ) / sizeof( adj[0] );
153 : 4 : int off_alloc = sizeof( off ) / sizeof( off[0] );
154 : 4 : int adj_size = -1, off_size = -1;
155 : 4 : iBase_EntityHandle* adj_ptr = adj;
156 : 4 : int* off_ptr = off;
157 : : iMesh_getEntArrAdj( mesh, HEXES[i][j], INTERVALS, iBase_VERTEX, &adj_ptr, &adj_alloc, &adj_size, &off_ptr,
158 [ + - ]: 4 : &off_alloc, &off_size, &err );
159 [ + - ]: 4 : CHECK_EQUAL( &adj[0], adj_ptr );
160 [ + - ]: 4 : CHECK_EQUAL( &off[0], off_ptr );
161 [ + - ]: 4 : CHECK_EQUAL( iBase_SUCCESS, err );
162 [ + - ]: 4 : CHECK_EQUAL( 8 * INTERVALS, adj_size );
163 [ + - ]: 4 : CHECK_EQUAL( 8 * INTERVALS, adj_alloc );
164 [ + - ]: 4 : CHECK_EQUAL( INTERVALS + 1, off_size );
165 [ + - ]: 4 : CHECK_EQUAL( INTERVALS + 1, off_alloc );
166 [ + + ]: 12 : for( int k = 0; k < INTERVALS; ++k )
167 : : {
168 [ + - ]: 8 : CHECK_EQUAL( 8 * k, off[k] );
169 : : iBase_EntityHandle conn[8];
170 : 8 : HEX_VERTS( i, j, k, conn );
171 [ + - ]: 8 : 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 : 1 : const int f = 0;
178 [ + + ]: 3 : for( int i = 0; i < INTERVALS; ++i )
179 : : {
180 : : iBase_EntityHandle adj[4 * INTERVALS];
181 : : int off[INTERVALS + 1];
182 : 2 : int adj_alloc = sizeof( adj ) / sizeof( adj[0] );
183 : 2 : int off_alloc = sizeof( off ) / sizeof( off[0] );
184 : 2 : int adj_size = -1, off_size = -1;
185 : 2 : iBase_EntityHandle* adj_ptr = adj;
186 : 2 : int* off_ptr = off;
187 : : iMesh_getEntArrAdj( mesh, FACES[f][i], INTERVALS, iBase_VERTEX, &adj_ptr, &adj_alloc, &adj_size, &off_ptr,
188 [ + - ]: 2 : &off_alloc, &off_size, &err );
189 [ + - ]: 2 : CHECK_EQUAL( &adj[0], adj_ptr );
190 [ + - ]: 2 : CHECK_EQUAL( &off[0], off_ptr );
191 [ + - ]: 2 : CHECK_EQUAL( iBase_SUCCESS, err );
192 [ + - ]: 2 : CHECK_EQUAL( 4 * INTERVALS, adj_size );
193 [ + - ]: 2 : CHECK_EQUAL( 4 * INTERVALS, adj_alloc );
194 [ + - ]: 2 : CHECK_EQUAL( INTERVALS + 1, off_size );
195 [ + - ]: 2 : CHECK_EQUAL( INTERVALS + 1, off_alloc );
196 [ + + ]: 6 : for( int k = 0; k < INTERVALS; ++k )
197 : : {
198 [ + - ]: 4 : CHECK_EQUAL( 4 * k, off[k] );
199 : : iBase_EntityHandle conn[4];
200 [ + - ]: 4 : QUAD_VERTS( f, i, k, conn );
201 [ + - ]: 4 : CHECK_ARRAYS_EQUAL( conn, 4, adj + off[k], off[k + 1] - off[k] );
202 : : }
203 : : }
204 : 1 : }
205 : :
206 : 1 : void test_getEntArrAdj_vertex()
207 : : {
208 [ + - ]: 1 : iMesh_Instance mesh = create_mesh();
209 : : int err;
210 : :
211 : : // get hexes adjacent to row of vertices at x=0,y=0;
212 : 1 : iBase_EntityHandle* adj = 0;
213 : 1 : int* off = 0;
214 : 1 : int adj_alloc = 0, off_alloc = 0;
215 : 1 : 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 [ + - ]: 1 : &off_size, &err );
218 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
219 [ + - ]: 1 : CHECK( 0 != adj );
220 [ + - ]: 1 : CHECK( 0 != off );
221 : : CHECK_EQUAL( 2 * INTERVALS,
222 [ + - ]: 1 : adj_size ); // INTERVALS+1 verts, end ones with one hex, others with two
223 [ + - ]: 1 : CHECK_EQUAL( INTERVALS + 2, off_size ); // one more than number of input handles
224 [ + - ]: 1 : CHECK( adj_alloc >= adj_size );
225 [ + - ]: 1 : CHECK( off_alloc >= off_size );
226 : :
227 : : // first and last vertices should have one adjacent hex
228 [ + - ]: 1 : CHECK_EQUAL( 1, off[1] - off[0] );
229 [ + - ]: 1 : CHECK_EQUAL( HEXES[0][0][0], adj[off[0]] );
230 [ + - ]: 1 : CHECK_EQUAL( 1, off[INTERVALS + 1] - off[INTERVALS] );
231 [ + - ]: 1 : CHECK_EQUAL( HEXES[0][0][INTERVALS - 1], adj[off[INTERVALS]] );
232 : : // middle ones should have two adjacent hexes
233 [ + + ]: 2 : for( int i = 1; i < INTERVALS; ++i )
234 : : {
235 [ + - ]: 1 : CHECK_EQUAL( 2, off[i + 1] - off[i] );
236 [ + - ]: 1 : CHECK_EQUAL( HEXES[0][0][i - 1], adj[off[i]] );
237 [ + - ]: 1 : CHECK_EQUAL( HEXES[0][0][i], adj[off[i] + 1] );
238 : : }
239 : :
240 : 1 : free( adj );
241 : 1 : free( off );
242 : 1 : }
243 : :
244 : 1 : void test_getEntArrAdj_up()
245 : : {
246 [ + - ]: 1 : iMesh_Instance mesh = create_mesh();
247 : : int err;
248 : :
249 : : // get hexes adjacent to a row of faces in the z=0 plane
250 : 1 : iBase_EntityHandle* adj = 0;
251 : 1 : int* off = 0;
252 : 1 : int adj_alloc = 0, off_alloc = 0;
253 : 1 : 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 [ + - ]: 1 : &off_size, &err );
256 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
257 [ + - ]: 1 : CHECK( 0 != adj );
258 [ + - ]: 1 : CHECK( 0 != off );
259 [ + - ]: 1 : CHECK_EQUAL( INTERVALS, adj_size ); // one hex adjacent to each skin face
260 [ + - ]: 1 : CHECK_EQUAL( INTERVALS + 1, off_size ); // one more than number of input handles
261 [ + - ]: 1 : CHECK( adj_alloc >= adj_size );
262 [ + - ]: 1 : CHECK( off_alloc >= off_size );
263 : :
264 [ + + ]: 3 : for( int i = 0; i < INTERVALS; ++i )
265 : : {
266 [ + - ]: 2 : CHECK_EQUAL( 1, off[i + 1] - off[i] );
267 [ + - ]: 2 : CHECK_EQUAL( HEXES[0][i][0], adj[off[i]] );
268 : : }
269 : :
270 : 1 : free( adj );
271 : 1 : free( off );
272 : 1 : }
273 : :
274 : 1 : void test_getEntArrAdj_down()
275 : : {
276 [ + - ]: 1 : iMesh_Instance mesh = create_mesh();
277 : : int err;
278 : :
279 : : // get quads adjacent to a edge-row of hexes
280 : 1 : iBase_EntityHandle* adj = 0;
281 : 1 : int* off = 0;
282 : 1 : int adj_alloc = 0, off_alloc = 0;
283 : 1 : 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 [ + - ]: 1 : &off_size, &err );
286 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
287 [ + - ]: 1 : CHECK( 0 != adj );
288 [ + - ]: 1 : CHECK( 0 != off );
289 [ + - ]: 1 : CHECK_EQUAL( 2 * INTERVALS + 2, adj_size ); // corner hexes adj to 3 faces, others adj to 2
290 [ + - ]: 1 : CHECK_EQUAL( INTERVALS + 1, off_size ); // one more than number of input handles
291 [ + - ]: 1 : CHECK( adj_alloc >= adj_size );
292 [ + - ]: 1 : CHECK( off_alloc >= off_size );
293 : :
294 : : // first (corner) hex should have three adjacent faces
295 [ + - ]: 1 : CHECK_EQUAL( 3, off[1] - off[0] );
296 : 1 : iBase_EntityHandle exp[3] = { FACES[0][0][0], FACES[3][0][0], FACES[4][0][0] };
297 : : iBase_EntityHandle act[3];
298 [ + - ]: 1 : std::copy( adj + off[0], adj + off[1], act );
299 [ + - ]: 1 : std::sort( exp, exp + 3 );
300 [ + - ]: 1 : std::sort( act, act + 3 );
301 [ + - ]: 1 : CHECK_ARRAYS_EQUAL( exp, 3, act, 3 );
302 : :
303 : : // last (corner) hex should have three adjacent faces
304 [ + - ]: 1 : CHECK_EQUAL( 3, off[INTERVALS] - off[INTERVALS - 1] );
305 : 1 : iBase_EntityHandle exp2[3] = { FACES[0][0][INTERVALS - 1], FACES[3][0][INTERVALS - 1], FACES[5][0][0] };
306 [ + - ]: 1 : std::copy( adj + off[INTERVALS - 1], adj + off[INTERVALS], act );
307 [ + - ]: 1 : std::sort( exp2, exp2 + 3 );
308 [ + - ]: 1 : std::sort( act, act + 3 );
309 [ + - ]: 1 : 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 : 1 : free( adj );
331 : 1 : free( off );
332 : 1 : }
333 : :
334 : 1 : void test_getEntArrAdj_invalid_size()
335 : : {
336 [ + - ]: 1 : iMesh_Instance mesh = create_mesh();
337 : 1 : int err = -1;
338 : :
339 : 1 : const int SPECIAL1 = 0xDeadBeef;
340 : 1 : const int SPECIAL2 = 0xCafe5;
341 : 1 : const int SPECIAL3 = 0xbabb1e;
342 : :
343 : : // test a downward query
344 : 1 : volatile int marker1 = SPECIAL1;
345 : : iBase_EntityHandle adj1[8 * INTERVALS - 1]; // one too small
346 : 1 : volatile int marker2 = SPECIAL2;
347 : : int off1[INTERVALS + 1];
348 : 1 : int adj1_alloc = sizeof( adj1 ) / sizeof( adj1[0] );
349 : 1 : int off1_alloc = sizeof( off1 ) / sizeof( off1[0] );
350 : : int adj_size, off_size;
351 : 1 : iBase_EntityHandle* adj_ptr = adj1;
352 : 1 : int* off_ptr = off1;
353 : : iMesh_getEntArrAdj( mesh, HEXES[0][0], INTERVALS, iBase_VERTEX, &adj_ptr, &adj1_alloc, &adj_size, &off_ptr,
354 [ + - ]: 1 : &off1_alloc, &off_size, &err );
355 [ + - ]: 1 : CHECK_EQUAL( &adj1[0], adj_ptr );
356 [ + - ]: 1 : CHECK_EQUAL( &off1[0], off_ptr );
357 : : // first ensure no stack corruption from writing off end of array
358 [ + - ]: 1 : CHECK_EQUAL( SPECIAL1, marker1 );
359 [ + - ]: 1 : CHECK_EQUAL( SPECIAL2, marker2 );
360 : : // now verify that it correctly failed
361 [ + - ]: 1 : CHECK_EQUAL( iBase_BAD_ARRAY_SIZE, err );
362 : :
363 : : // now test an upwards query
364 : 1 : volatile int marker3 = SPECIAL3;
365 : : int off2[INTERVALS];
366 : 1 : volatile int marker4 = SPECIAL1;
367 : 1 : int off2_alloc = sizeof( off2 ) / sizeof( off2[0] );
368 : 1 : err = iBase_SUCCESS;
369 : 1 : adj_ptr = adj1;
370 : 1 : off_ptr = off2;
371 : : iMesh_getEntArrAdj( mesh, VERTS[0][0], INTERVALS + 1, iBase_REGION, &adj_ptr, &adj1_alloc, &adj_size, &off_ptr,
372 [ + - ]: 1 : &off2_alloc, &off_size, &err );
373 : : // first ensure no stack corruption from writing off end of array
374 [ + - ]: 1 : CHECK_EQUAL( &adj1[0], adj_ptr );
375 [ + - ]: 1 : CHECK_EQUAL( &off2[0], off_ptr );
376 [ + - ]: 1 : CHECK_EQUAL( SPECIAL3, marker3 );
377 [ + - ]: 1 : CHECK_EQUAL( SPECIAL1, marker4 );
378 : : // now verify that it correctly failed
379 [ + - ]: 1 : CHECK_EQUAL( iBase_BAD_ARRAY_SIZE, err );
380 : 1 : }
381 : :
382 : 1 : void test_getEntArrAdj_none()
383 : : {
384 [ + - ]: 1 : iMesh_Instance mesh = create_mesh();
385 : 1 : int err = -1;
386 : :
387 : 1 : iBase_EntityHandle* adj = 0;
388 : 1 : int* off = 0;
389 : 1 : int adj_alloc = 0, off_alloc = 0;
390 : 1 : int adj_size = -1, off_size = -1;
391 [ + - ]: 1 : iMesh_getEntArrAdj( mesh, NULL, 0, iBase_REGION, &adj, &adj_alloc, &adj_size, &off, &off_alloc, &off_size, &err );
392 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
393 [ + - ]: 1 : CHECK_EQUAL( 0, adj_alloc );
394 [ + - ]: 1 : CHECK_EQUAL( 0, adj_size );
395 [ + - ]: 1 : CHECK_EQUAL( 1, off_size );
396 [ + - ]: 1 : CHECK( off_alloc >= 1 );
397 [ + - ]: 1 : CHECK_EQUAL( 0, off[0] );
398 : :
399 : 1 : free( off );
400 : 1 : }
401 : :
402 : 1 : void test_existinterface()
403 : : {
404 : : // test construction of an imesh instance from a core instance
405 [ + - ][ + - ]: 1 : moab::Core* core = new moab::Core();
406 [ + - ][ + - ]: 1 : MBiMesh* mesh = new MBiMesh( core );
407 : 1 : iMesh_Instance imesh = reinterpret_cast< iMesh_Instance >( mesh );
408 : :
409 : : // make sure we can call imesh functions
410 : : int dim, err;
411 [ + - ]: 1 : iMesh_getGeometricDimension( imesh, &dim, &err );
412 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
413 : :
414 : : // now make sure we can delete the instance without it deleting the MOAB instance
415 [ + - ]: 1 : iMesh_dtor( imesh, &err );
416 [ + - ]: 1 : CHECK_EQUAL( err, iBase_SUCCESS );
417 : :
418 [ + - ]: 1 : ErrorCode rval = core->get_number_entities_by_dimension( 0, 0, dim );
419 [ + - ]: 1 : CHECK_EQUAL( moab::MB_SUCCESS, rval );
420 : :
421 : : // finally, delete the MOAB instance
422 [ + - ]: 1 : delete core;
423 : 1 : }
424 : :
425 : 1 : void test_tags_retrieval()
426 : : {
427 : : iMesh_Instance mesh;
428 : : int err;
429 [ + - ]: 1 : iMesh_newMesh( "", &mesh, &err, 0 );
430 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
431 : :
432 : : iBase_EntitySetHandle root_set;
433 [ + - ]: 1 : iMesh_getRootSet( mesh, &root_set, &err );
434 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
435 : :
436 : : // open a file with var len tags (sense tags)
437 : : // they should be filtered out
438 [ + - ]: 1 : std::string filename = STRINGIFY( MESHDIR ) "/PB.h5m";
439 : :
440 [ + - ]: 1 : iMesh_load( mesh, root_set, filename.c_str(), NULL, &err, filename.length(), 0 );
441 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
442 : :
443 : 1 : iBase_EntitySetHandle* contained_set_handles = NULL;
444 : 1 : 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 [ + - ]: 1 : &contained_set_handles_size, &err );
449 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
450 : : // get tags for all sets
451 [ + + ]: 4 : for( int i = 0; i < contained_set_handles_size; i++ )
452 : : {
453 : 3 : iBase_TagHandle* tag_handles = NULL;
454 : 3 : int tag_handles_allocated = 0;
455 : : int tag_handles_size;
456 : 3 : iMesh_getAllEntSetTags( mesh, contained_set_handles[i], &tag_handles, &tag_handles_allocated, &tag_handles_size,
457 [ + - ]: 3 : &err );
458 [ + - ]: 3 : CHECK_EQUAL( iBase_SUCCESS, err );
459 : :
460 [ + + ]: 9 : for( int j = 0; j < tag_handles_size; j++ )
461 : : {
462 : : int tagSize;
463 [ + - ]: 6 : iMesh_getTagSizeValues( mesh, tag_handles[j], &tagSize, &err );
464 [ + - ]: 6 : CHECK_EQUAL( iBase_SUCCESS, err );
465 : : }
466 : 3 : free( tag_handles );
467 : : }
468 : 1 : free( contained_set_handles );
469 : :
470 : : // Delete the iMesh instance
471 [ + - ]: 1 : iMesh_dtor( mesh, &err );
472 [ + - ]: 1 : CHECK_EQUAL( iBase_SUCCESS, err );
473 : :
474 : 1 : return;
475 : : }
476 : :
477 : 0 : void test_invalid_parallel_option()
478 : : {
479 : : iMesh_Instance mesh;
480 : : int err;
481 [ # # ]: 0 : iMesh_newMesh( "moab:PARALLEL", &mesh, &err, 13 );
482 [ # # ]: 0 : CHECK_EQUAL( iBase_NOT_SUPPORTED, err );
483 : :
484 [ # # ]: 0 : iMesh_dtor( mesh, &err );
485 [ # # ]: 0 : CHECK_EQUAL( iBase_SUCCESS, err );
486 [ + - ][ + - ]: 4 : }
|
