Branch data Line data Source code
1 : : /**
2 : : * MOAB, a Mesh-Oriented datABase, is a software component for creating,
3 : : * storing and accessing finite element mesh data.
4 : : *
5 : : * Copyright 2004 Sandia Corporation. Under the terms of Contract
6 : : * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
7 : : * retains certain rights in this software.
8 : : *
9 : : * This library is free software; you can redistribute it and/or
10 : : * modify it under the terms of the GNU Lesser General Public
11 : : * License as published by the Free Software Foundation; either
12 : : * version 2.1 of the License, or (at your option) any later version.
13 : : *
14 : : */
15 : :
16 : : /** TSTT Mesh Interface Unit Test
17 : : *
18 : : * This program tests TSTT mesh interface functions through the SIDL interface.
19 : : * In a nutshell, the test creates (or accesses) an implementation instance,
20 : : * tells it to load a file (specified on the command line), then calls a
21 : : * number of functions evaluating that mesh. This test also tests mesh, set
22 : : * and tag creation and evaluation functions.
23 : : *
24 : : * Usage: testcxx <mesh_file_name>
25 : : *
26 : : * Compiling
27 : : * ---------
28 : : * 1. Build your server (your implementation of the TSTT mesh interface) under
29 : : * SIDL/Babel and put it in a library in the Babel-generated server directory,
30 : : * ${SERVER_DIR}/libimpl.so. Any include files needed to instantiate this
31 : : * server from applications should also be in that directory. See note a) below.
32 : : * 2. Change the definition of IMPLEMENTATION_CLASS below to be the
33 : : * namespace-qualified name of your implementation class. This definition is
34 : : * used in the main to instantiate the server using the SIDL _create function, e.g.
35 : : * . TSTTB::Mesh mesh = IMPLEMENTATION_CLASS._create();
36 : : * (we put the definition of IMPLEMENTATION_CLASS at the top of this file so that
37 : : * you don't have to understand the rest of the source code to use this test). See
38 : : * note b) below.
39 : : * 3. Include the file(s) needed which declare the implementation's namespace and
40 : : * class
41 : : * 4. Compile this test file to an object file:
42 : : * g++ -fpic -I. -I${BABEL}/include -I${SERVER_DIR} -c testcxx.cpp
43 : : * 5. Link the application:
44 : : * g++ -o testcxx testcxx.o -ltest -L${BABEL_LIBS} -lsidl
45 : : *
46 : : * Notes
47 : : * -----
48 : : * a) The files don't absolutely need to be arranged as described above. For
49 : : * example, some projects put their custom implementation files somewhere besides
50 : : * ${SERVER_DIR}, to keep them separate from Babel-generated files.
51 : : * b) This test assumes interface instances are created using a direct call to the
52 : : * SIDL _create() function for that class. Another way to do this would be to
53 : : * call a factory linked into the test. To change the method used to construct
54 : : * the interface instance for this test, see the use of IMPLEMENTATION_CLASS towards
55 : : * the end of this file.
56 : : */
57 : :
58 : : #include <stdio.h>
59 : : #include <string.h>
60 : : #include <stdlib.h>
61 : : #include "iMesh.h"
62 : : #include "iMesh_extensions.h"
63 : : #include "moab/Types.hpp"
64 : : #include "TestUtil.hpp"
65 : : using namespace moab;
66 : : extern enum iBase_ErrorType iBase_ERROR_MAP[MB_FAILURE + 1];
67 : :
68 : : #define FALSE 0
69 : : #define TRUE 1
70 : :
71 : : #define DEFAULT_TEST_FILE brick.vtk
72 : :
73 : : // clang-format off
74 : :
75 : : #ifdef SRCDIR
76 : : #define DEFAULT_INPUT_FILE STRINGIFY( SRCDIR/DEFAULT_TEST_FILE )
77 : : #else
78 : : #define DEFAULT_INPUT_FILE STRINGIFY( DEFAULT_TEST_FILE )
79 : : #endif
80 : :
81 : : static bool assert_pass;
82 : : #define ASSERT( COND ) \
83 : : assert_pass = true; \
84 : : if( !( COND ) ) \
85 : : { \
86 : : PRINT_ASSERT_FAILURE( #COND, __FILE__, __LINE__ ); \
87 : : assert_pass = false; \
88 : : }
89 : :
90 : 0 : void PRINT_ASSERT_FAILURE( const char* cond, const char* file, int line )
91 : : {
92 : 0 : printf( "Condition: %s\n", cond );
93 : 0 : printf( " failed at %s line %d\n", file, line );
94 : 0 : }
95 : :
96 : : #define CHK( err ) \
97 : : if( err != iBase_SUCCESS ) do \
98 : : { \
99 : : printf( "%s:%d ITAPS error %d\n", __FILE__, __LINE__, err ); \
100 : : return 0; \
101 : : } while( 0 )
102 : :
103 : : // clang-format on
104 : :
105 : : static iBase_EntitySetHandle root_set;
106 : :
107 : : /*!
108 : : prints out a result string based on the value of error_code
109 : : */
110 : 15 : void handle_error_code( const int result, int* number_failed, int* /*number_not_implemented*/, int* number_successful )
111 : : {
112 [ + - ]: 15 : if( result )
113 : : {
114 : 15 : printf( "Success\n" );
115 : 15 : ( *number_successful )++;
116 : : }
117 : : else
118 : : {
119 : 0 : printf( "Failure\n" );
120 : 0 : ( *number_failed )++;
121 : : }
122 : 15 : }
123 : :
124 : : /*!
125 : : @test
126 : : Load Mesh
127 : : @li Load a mesh file
128 : : */
129 : 1 : int load_mesh_test( const char* filename, iMesh_Instance mesh )
130 : : {
131 : : /* load a mesh */
132 : : int result;
133 [ + - ]: 1 : iMesh_load( mesh, root_set, filename, NULL, &result, strlen( filename ), 0 );
134 [ - + ]: 1 : if( iBase_SUCCESS != result )
135 : : {
136 [ # # ]: 0 : printf( "ERROR : can not load a mesh from file %s\n", filename );
137 : 0 : return FALSE;
138 : : }
139 : :
140 : 1 : return TRUE;
141 : : }
142 : :
143 : : #define TEST_ERROR_CODE( A, B ) \
144 : : if( iBase_ERROR_MAP[( A )] != ( B ) ) \
145 : : { \
146 : : printf( "ERROR: Invalid mapping for MOAB error code %s\n", #A ); \
147 : : printf( " Expected %d, actual is %d\n", (int)iBase_ERROR_MAP[( A )], (int)( B ) ); \
148 : : return FALSE; \
149 : : }
150 : :
151 : 1 : int error_code_test( iMesh_Instance /*mesh*/ )
152 : : {
153 [ - + ]: 1 : TEST_ERROR_CODE( MB_SUCCESS, iBase_SUCCESS )
154 [ - + ]: 1 : TEST_ERROR_CODE( MB_TYPE_OUT_OF_RANGE, iBase_INVALID_ENTITY_TYPE )
155 [ - + ]: 1 : TEST_ERROR_CODE( MB_MEMORY_ALLOCATION_FAILED, iBase_MEMORY_ALLOCATION_FAILED )
156 [ - + ]: 1 : TEST_ERROR_CODE( MB_ENTITY_NOT_FOUND, iBase_INVALID_ENTITY_HANDLE )
157 [ - + ]: 1 : TEST_ERROR_CODE( MB_TAG_NOT_FOUND, iBase_TAG_NOT_FOUND )
158 [ - + ]: 1 : TEST_ERROR_CODE( MB_FILE_DOES_NOT_EXIST, iBase_FILE_NOT_FOUND )
159 [ - + ]: 1 : TEST_ERROR_CODE( MB_UNSUPPORTED_OPERATION, iBase_NOT_SUPPORTED )
160 [ - + ]: 1 : TEST_ERROR_CODE( MB_UNHANDLED_OPTION, iBase_INVALID_ARGUMENT )
161 [ - + ]: 1 : TEST_ERROR_CODE( MB_FAILURE, iBase_FAILURE )
162 : 1 : return TRUE;
163 : : }
164 : :
165 : : /*!
166 : : @test
167 : : TSTT topology dimension Test
168 : : @li Check 2d topology dimensions
169 : : */
170 : 1 : int topology_dimension_test( iMesh_Instance mesh )
171 : : {
172 : 1 : iBase_EntityHandle* faces = NULL;
173 : 1 : int faces_alloc = 0, faces_size;
174 : : int result, i;
175 : 1 : int* dimensions = NULL;
176 : 1 : int dimensions_alloc = 0, dimensions_size;
177 : :
178 : : /* first get 2D entities */
179 [ + - ]: 1 : iMesh_getEntities( mesh, root_set, iBase_FACE, iMesh_ALL_TOPOLOGIES, &faces, &faces_alloc, &faces_size, &result );
180 [ - + ]: 1 : if( iBase_SUCCESS != result )
181 : : {
182 [ # # ]: 0 : printf( "Failed to get faces in entity_sets_test.\n" );
183 : 0 : return FALSE;
184 : : }
185 : :
186 : : /* get dimensions of faces */
187 [ + - ]: 1 : iMesh_getEntArrType( mesh, faces, faces_size, &dimensions, &dimensions_alloc, &dimensions_size, &result );
188 [ - + ]: 1 : if( iBase_SUCCESS != result )
189 : : {
190 [ # # ]: 0 : printf( "Failed to get dimensions of faces in topology_test.\n" );
191 : 0 : free( faces );
192 : 0 : return FALSE;
193 : : }
194 : :
195 [ - + ]: 1 : if( dimensions_size != faces_size )
196 : : {
197 [ # # ]: 0 : printf( "Didn't get the right number of types in topology_test.\n" );
198 : 0 : free( faces );
199 : 0 : free( dimensions );
200 : 0 : return FALSE;
201 : : }
202 : :
203 : : /* make sure all elements are 2D */
204 [ + + ]: 601 : for( i = 0; i < faces_size; i++ )
205 : : {
206 [ - + ]: 600 : if( dimensions[i] != iBase_FACE )
207 : : {
208 : 0 : free( faces );
209 : 0 : free( dimensions );
210 : 0 : return FALSE;
211 : : }
212 : : }
213 : :
214 : 1 : free( faces );
215 : 1 : free( dimensions );
216 : :
217 : 1 : return TRUE;
218 : : }
219 : :
220 : : /*!
221 : : @test
222 : : TSTT topology adjacency Test
223 : : @li Check topology information
224 : : @li Check adjacency
225 : : @li Get interior and exterior elements
226 : : */
227 : : /* make each topological entity vectors, check their topology */
228 : : /* types, get interior and exterior faces of hexes */
229 : 1 : int topology_adjacency_test( iMesh_Instance mesh )
230 : : {
231 : : int result, i, j, entities_alloc, entities_size, *topologies;
232 : : int topologies_alloc, topologies_size;
233 : 1 : iBase_EntityHandle *entities, *entity_vectors[iMesh_ALL_TOPOLOGIES] = { NULL };
234 : 1 : int entity_vectors_sizes[iMesh_ALL_TOPOLOGIES] = { 0 };
235 : : int top_j, num_tops, region_type, num_region;
236 : 1 : iBase_EntityHandle* adj_faces = NULL;
237 : 1 : int adj_faces_alloc = 0, adj_faces_size;
238 : 1 : int* face_offsets = NULL;
239 : 1 : int face_offsets_alloc = 0, face_offsets_size, face_loaded;
240 : 1 : iBase_EntityHandle* adj_regions = NULL;
241 : 1 : int adj_regions_alloc = 0, adj_regions_size;
242 : 1 : int* region_offsets = NULL;
243 : 1 : int region_offsets_alloc = 0, region_offsets_size;
244 : : iBase_EntityHandle *interior, *exterior;
245 : 1 : int num_int = 0, num_ext = 0, found, next_offset, iter;
246 : : int num_faces_per_region;
247 : : ;
248 : :
249 : : /* fill the vectors of each topology entities */
250 : : /* like lines vector, polygon vector, triangle vector, */
251 : : /* quadrilateral, polyhedrron, tet, hex, prism, pyramid, */
252 : : /* septahedron vectors */
253 [ + + ]: 12 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
254 : : {
255 : 11 : entities = NULL;
256 : 11 : entities_alloc = 0;
257 [ + - ]: 11 : iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, i, &entities, &entities_alloc, &entities_size, &result );
258 [ - + ]: 11 : if( iBase_SUCCESS != result )
259 : : {
260 [ # # ]: 0 : printf( "Failed to get entities in adjacencies_test.\n" );
261 : 0 : return FALSE;
262 : : }
263 : :
264 [ + + ]: 11 : if( entities_alloc > 0 )
265 : : {
266 : 4 : topologies = NULL;
267 : 4 : topologies_alloc = 0;
268 : : iMesh_getEntArrTopo( mesh, entities, entities_alloc, &topologies, &topologies_alloc, &topologies_size,
269 [ + - ]: 4 : &result );
270 [ - + ]: 4 : if( iBase_SUCCESS != result )
271 : : {
272 [ # # ]: 0 : printf( "Failed to get topologies in adjacencies_test.\n" );
273 : 0 : return FALSE;
274 : : }
275 : :
276 [ - + ]: 4 : if( topologies_size != entities_size )
277 : : {
278 : : printf( "Didn't get the right number of topologies "
279 [ # # ]: 0 : "in topology_adjacency_test.\n" );
280 : 0 : free( topologies );
281 : 0 : free( entities );
282 : 0 : return FALSE;
283 : : }
284 : :
285 : : /* put entities into vectors of each topology */
286 : 4 : entity_vectors[i] = (iBase_EntityHandle*)malloc( entities_size * sizeof( iBase_EntityHandle ) );
287 : :
288 [ + + ]: 4135 : for( j = 0; j < entities_size; j++ )
289 : : {
290 [ + - ][ - + ]: 4131 : if( topologies[j] < iMesh_POINT || topologies[j] >= iMesh_ALL_TOPOLOGIES )
291 [ # # ]: 0 : printf( "Didn't find entity type for this topology." );
292 : : else
293 : : {
294 : 4131 : entity_vectors[i][entity_vectors_sizes[i]] = entities[j];
295 : 4131 : entity_vectors_sizes[i]++;
296 : : }
297 : : }
298 : :
299 : 4 : free( topologies );
300 : : }
301 : :
302 : 11 : free( entities );
303 : : }
304 : :
305 : : /* check number of entities for each topology */
306 [ + + ]: 12 : for( top_j = 0; top_j < iMesh_ALL_TOPOLOGIES; top_j++ )
307 : : {
308 : 11 : num_tops = 0;
309 [ + - ]: 11 : iMesh_getNumOfTopo( mesh, root_set, top_j, &num_tops, &result );
310 [ - + ]: 11 : if( iBase_SUCCESS != result )
311 : : {
312 [ # # ]: 0 : printf( "Failed to get number of topologies in adjacencies_test.\n" );
313 [ # # ]: 0 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
314 : 0 : free( entity_vectors[i] );
315 : 0 : return FALSE;
316 : : }
317 : :
318 [ - + ]: 11 : if( entity_vectors_sizes[top_j] != num_tops )
319 : : {
320 [ # # ]: 0 : printf( "Topology count mismatch.\n" );
321 [ # # ]: 0 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
322 : 0 : free( entity_vectors[i] );
323 : 0 : return FALSE;
324 : : }
325 : : }
326 : :
327 : : /* change if 3d topology entities are added or removed */
328 [ + + ]: 6 : for( region_type = iMesh_TETRAHEDRON; region_type < iMesh_ALL_TOPOLOGIES; region_type++ )
329 : : {
330 : : /* get all adjacent faces of regions */
331 : 5 : iBase_EntityHandle* region_vector = entity_vectors[region_type];
332 : :
333 : 5 : num_region = entity_vectors_sizes[region_type];
334 : :
335 [ + + ]: 5 : if( num_region > 0 )
336 : : {
337 : 1 : adj_faces = NULL;
338 : 1 : adj_faces_alloc = 0;
339 : 1 : face_offsets = NULL;
340 : 1 : face_offsets_alloc = 0;
341 : :
342 : : iMesh_getEntArrAdj( mesh, region_vector, num_region, iBase_FACE, &adj_faces, &adj_faces_alloc,
343 [ + - ]: 1 : &adj_faces_size, &face_offsets, &face_offsets_alloc, &face_offsets_size, &result );
344 [ - + ]: 1 : if( iBase_SUCCESS != result )
345 : : {
346 [ # # ]: 0 : printf( "Failed to get adjacent faces of regions in adjacencies_test.\n" );
347 [ # # ]: 0 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
348 : 0 : free( entity_vectors[i] );
349 : 0 : return FALSE;
350 : : }
351 : :
352 [ - + ]: 1 : if( num_region + 1 != face_offsets_size )
353 : : {
354 : : printf( "Number of offsets didn't agree with number of "
355 [ # # ]: 0 : "regions in topology_adjacency_test.\n" );
356 : 0 : free( face_offsets );
357 : 0 : free( adj_faces );
358 [ # # ]: 0 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
359 : 0 : free( entity_vectors[i] );
360 : 0 : return FALSE;
361 : : }
362 : :
363 : 1 : face_loaded = FALSE;
364 : :
365 : : /* check # of faces really loaded */
366 [ - + ]: 1 : if( region_type == iMesh_TETRAHEDRON )
367 : : {
368 [ # # ]: 0 : if( adj_faces_size == 4 * num_region ) face_loaded = TRUE;
369 : : }
370 [ + - ]: 1 : else if( region_type == iMesh_HEXAHEDRON )
371 : : {
372 [ - + ]: 1 : if( adj_faces_size == 6 * num_region ) face_loaded = TRUE;
373 : : }
374 [ # # ]: 0 : else if( region_type == iMesh_PRISM )
375 : : {
376 [ # # ]: 0 : if( adj_faces_size == 5 * num_region ) face_loaded = TRUE;
377 : : }
378 [ # # ]: 0 : else if( region_type == iMesh_PYRAMID )
379 : : {
380 [ # # ]: 0 : if( adj_faces_size == 5 * num_region ) face_loaded = TRUE;
381 : : }
382 [ # # ]: 0 : else if( region_type == iMesh_SEPTAHEDRON )
383 : : {
384 [ # # ]: 0 : if( adj_faces_size == 7 * num_region ) face_loaded = TRUE;
385 : : }
386 : : else
387 : 0 : face_loaded = FALSE;
388 : :
389 : : /* get all adjacent regions of adjacent faces */
390 : 1 : adj_regions = NULL;
391 : 1 : adj_regions_alloc = 0;
392 : 1 : region_offsets = NULL;
393 : 1 : region_offsets_alloc = 0;
394 : : iMesh_getEntArrAdj( mesh, adj_faces, adj_faces_size, iBase_REGION, &adj_regions, &adj_regions_alloc,
395 : : &adj_regions_size, ®ion_offsets, ®ion_offsets_alloc, ®ion_offsets_size,
396 [ + - ]: 1 : &result );
397 [ - + ]: 1 : if( iBase_SUCCESS != result )
398 : : {
399 [ # # ]: 0 : printf( "Failed to get regions from faces in adjacencies_test.\n" );
400 : 0 : free( face_offsets );
401 : 0 : free( adj_faces );
402 [ # # ]: 0 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
403 : 0 : free( entity_vectors[i] );
404 : 0 : return FALSE;
405 : : }
406 : :
407 [ - + ]: 1 : if( adj_faces_size + 1 != region_offsets_size )
408 : : {
409 : : printf( "Number of offsets didn't agree with number of faces in "
410 [ # # ]: 0 : "topology_adjacency_test.\n" );
411 : 0 : free( face_offsets );
412 : 0 : free( region_offsets );
413 : 0 : free( adj_faces );
414 : 0 : free( adj_regions );
415 [ # # ]: 0 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
416 : 0 : free( entity_vectors[i] );
417 : 0 : return FALSE;
418 : : }
419 : :
420 : 1 : interior = (iBase_EntityHandle*)malloc( adj_faces_size * sizeof( iBase_EntityHandle ) ),
421 : 1 : exterior = (iBase_EntityHandle*)malloc( adj_faces_size * sizeof( iBase_EntityHandle ) );
422 : 1 : num_int = 0;
423 : 1 : num_ext = 0;
424 : :
425 : : /* find the interior faces having two adjacent regions */
426 [ + + ]: 601 : for( i = 0; i < adj_faces_size; i++ )
427 : : {
428 : 600 : next_offset = 0;
429 [ + + ]: 600 : if( i == adj_faces_size - 1 )
430 : 1 : next_offset = adj_regions_size;
431 : : else
432 : 599 : next_offset = region_offsets[i + 1];
433 : :
434 [ - + ]: 600 : if( next_offset - region_offsets[i] == 2 )
435 : : {
436 : 0 : found = FALSE;
437 [ # # ]: 0 : for( iter = 0; iter < num_int; iter++ )
438 : : {
439 [ # # ]: 0 : if( interior[iter] == adj_faces[i] )
440 : : {
441 : 0 : found = TRUE;
442 : 0 : break;
443 : : }
444 : : }
445 [ # # ]: 0 : if( !found ) interior[num_int++] = adj_faces[i];
446 : : }
447 : : }
448 : :
449 : : /* now remove any interior faces from the previous adjacent faces list */
450 : : /* and we should be left with exterior faces */
451 [ + + ]: 601 : for( i = 0; i < adj_faces_size; i++ )
452 : : {
453 : 600 : found = FALSE;
454 [ - + ]: 600 : for( iter = 0; iter < num_int; iter++ )
455 : : {
456 [ # # ]: 0 : if( interior[iter] == adj_faces[i] )
457 : : {
458 : 0 : found = TRUE;
459 : 0 : break;
460 : : }
461 : : }
462 [ + - ]: 600 : if( !found ) exterior[num_ext++] = adj_faces[i];
463 : : }
464 : :
465 : 1 : num_faces_per_region = face_offsets[1] - face_offsets[0];
466 : :
467 : : /* check # of exterior and interior faces */
468 : : /* should be #exterior_faces + 2 * #interior_faces = #faces_per_region */
469 : : /* * #regions */
470 [ - + ]: 1 : if( face_loaded )
471 : : {
472 [ # # ]: 0 : if( num_ext + 2 * num_int != num_faces_per_region * num_region )
473 : : {
474 : : printf( "exterior/interior failure: %d ext, %d int, %d regions, %d faces per\n", num_ext, num_int,
475 [ # # ]: 0 : num_region, num_faces_per_region );
476 : 0 : free( face_offsets );
477 : 0 : free( region_offsets );
478 : 0 : free( adj_faces );
479 : 0 : free( adj_regions );
480 : 0 : free( interior );
481 : 0 : free( exterior );
482 [ # # ]: 0 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
483 : 0 : free( entity_vectors[i] );
484 : 0 : return FALSE;
485 : : }
486 : : }
487 : :
488 : 1 : free( face_offsets );
489 : 1 : free( region_offsets );
490 : 1 : free( adj_faces );
491 : 1 : free( adj_regions );
492 : 1 : free( interior );
493 : 1 : free( exterior );
494 : : }
495 : : }
496 : :
497 [ + + ]: 12 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; i++ )
498 : 11 : free( entity_vectors[i] );
499 : :
500 : 1 : return TRUE;
501 : : }
502 : :
503 : 27024 : int qsort_comp_handles( const void* h1, const void* h2 )
504 : : {
505 : 27024 : return *(char**)h1 - *(char**)h2;
506 : : }
507 : :
508 : : /*!
509 : : @test
510 : : TSTT EntityType Connectivity Test
511 : : @li Get coordinates for all type enities
512 : : */
513 : :
514 : 1 : int entity_connectivity_test( iMesh_Instance mesh )
515 : : {
516 : : int type, result;
517 : : int *offsets, offsets_alloc, offsets_size;
518 : : int *indices, indices_alloc, indices_size;
519 : : iBase_EntityHandle *entities, *adj_ents, *entities2, *sorted;
520 : : int entities_alloc, entities_size, adj_ents_alloc, adj_ents_size;
521 : : int entities2_alloc, entities2_size;
522 : 1 : iBase_EntityHandle adj_ents2[27], *adj_ents2_ptr = adj_ents2;
523 : 1 : int adj_ents2_alloc = 27, adj_ents2_size, i, size;
524 : :
525 [ + + ]: 4 : for( type = iBase_EDGE; type < iBase_ALL_TYPES; type++ )
526 : : {
527 : 3 : entities = NULL;
528 : 3 : entities_alloc = 0;
529 : 3 : adj_ents = NULL;
530 : 3 : adj_ents_alloc = 0;
531 : 3 : indices = NULL;
532 : 3 : indices_alloc = 0;
533 : 3 : offsets = NULL;
534 : 3 : offsets_alloc = 0;
535 : : iMesh_getAdjEntIndices( mesh, root_set, type, iMesh_ALL_TOPOLOGIES, iBase_VERTEX, &entities, &entities_alloc,
536 : : &entities_size, &adj_ents, &adj_ents_alloc, &adj_ents_size, &indices, &indices_alloc,
537 [ + - ]: 3 : &indices_size, &offsets, &offsets_alloc, &offsets_size, &result );
538 [ - + ]: 3 : if( iBase_SUCCESS != result )
539 : : {
540 [ # # ]: 0 : printf( "Failed to get indices of vertices in connectivity_test, type=%d.\n", type );
541 : 0 : return FALSE;
542 : : }
543 : :
544 [ - + ]: 3 : if( entities_alloc != entities_size )
545 : : {
546 [ # # ]: 0 : printf( "Number of entities didn't agree with array size in connectivity_test.\n" );
547 : 0 : free( entities );
548 : 0 : free( adj_ents );
549 : 0 : free( indices );
550 : 0 : free( offsets );
551 : 0 : return FALSE;
552 : : }
553 : :
554 [ - + ]: 3 : if( offsets_alloc != offsets_size )
555 : : {
556 [ # # ]: 0 : printf( "Number of offsets didn't agree with array size in connectivity_test.\n" );
557 : 0 : free( entities );
558 : 0 : free( adj_ents );
559 : 0 : free( indices );
560 : 0 : free( offsets );
561 : 0 : return FALSE;
562 : : }
563 : :
564 [ - + ]: 3 : if( indices_alloc != indices_size )
565 : : {
566 [ # # ]: 0 : printf( "Number of indices didn't agree with array size in connectivity_test.\n" );
567 : 0 : free( entities );
568 : 0 : free( adj_ents );
569 : 0 : free( indices );
570 : 0 : free( offsets );
571 : 0 : return FALSE;
572 : : }
573 : :
574 [ - + ]: 3 : if( adj_ents_alloc != adj_ents_size )
575 : : {
576 : : printf( "Number of adjacent entities didn't agree with array size in "
577 [ # # ]: 0 : "connectivity_test.\n" );
578 : 0 : free( entities );
579 : 0 : free( adj_ents );
580 : 0 : free( indices );
581 : 0 : free( offsets );
582 : 0 : return FALSE;
583 : : }
584 : :
585 [ - + ]: 3 : if( offsets_size != entities_size + 1 )
586 : : {
587 [ # # ]: 0 : printf( "Invalid/inconsistent offset size from iMesh_getAdjEntIndices.\n" );
588 : 0 : free( entities );
589 : 0 : free( adj_ents );
590 : 0 : free( indices );
591 : 0 : free( offsets );
592 : 0 : return FALSE;
593 : : }
594 : :
595 : : /* check that results are valid */
596 [ + + ]: 2803 : for( i = 0; i < entities_size; ++i )
597 : : {
598 [ + - ][ - + ]: 2800 : ASSERT( offsets[i] < offsets[i + 1] && offsets[i] < indices_size );
[ # # ]
599 [ - + ]: 2800 : if( !assert_pass )
600 : : {
601 : 0 : free( entities );
602 : 0 : free( adj_ents );
603 : 0 : free( indices );
604 : 0 : free( offsets );
605 : 0 : return FALSE;
606 : : }
607 : : }
608 : :
609 [ + + ]: 12803 : for( i = 0; i < indices_size; ++i )
610 : : {
611 [ + - ][ - + ]: 12800 : ASSERT( indices[i] >= 0 && indices[i] < adj_ents_size );
[ # # ]
612 [ - + ]: 12800 : if( !assert_pass )
613 : : {
614 : 0 : free( entities );
615 : 0 : free( adj_ents );
616 : 0 : free( indices );
617 : 0 : free( offsets );
618 : 0 : return FALSE;
619 : : }
620 : : }
621 : :
622 : : /* compare initial entity list against result of iMesh_getEntities */
623 : 3 : entities2 = NULL;
624 : 3 : entities2_alloc = 0;
625 : : iMesh_getEntities( mesh, root_set, type, iMesh_ALL_TOPOLOGIES, &entities2, &entities2_alloc, &entities2_size,
626 [ + - ]: 3 : &result );
627 [ - + ][ # # ]: 3 : ASSERT( iBase_SUCCESS == result );
628 [ - + ]: 3 : if( !assert_pass )
629 : : {
630 : 0 : free( entities );
631 : 0 : free( adj_ents );
632 : 0 : free( indices );
633 : 0 : free( offsets );
634 : 0 : return FALSE;
635 : : }
636 : :
637 : 3 : size = sizeof( iBase_EntityHandle ) * entities_size;
638 : 3 : sorted = (iBase_EntityHandle*)malloc( size );
639 : 3 : memcpy( sorted, entities, size );
640 [ + - ]: 3 : qsort( sorted, entities_size, sizeof( iBase_EntityHandle ), &qsort_comp_handles );
641 [ + - ]: 3 : qsort( entities2, entities2_size, sizeof( iBase_EntityHandle ), &qsort_comp_handles );
642 : :
643 [ + - ][ - + ]: 3 : ASSERT( entities_size == entities2_size && !memcmp( sorted, entities2, size ) );
[ # # ]
644 [ - + ]: 3 : if( !assert_pass )
645 : : {
646 : 0 : free( entities );
647 : 0 : free( adj_ents );
648 : 0 : free( indices );
649 : 0 : free( offsets );
650 : 0 : free( entities2 );
651 : 0 : free( sorted );
652 : 0 : return FALSE;
653 : : }
654 : :
655 : 3 : free( entities2 );
656 : 3 : free( sorted );
657 : :
658 : : /* compare results against output of iMesh_getEntAdj */
659 [ + + ]: 2803 : for( i = 0; i < entities_size; ++i )
660 : : {
661 : 2800 : iMesh_getEntAdj( mesh, entities[i], iBase_VERTEX, &adj_ents2_ptr, &adj_ents2_alloc, &adj_ents2_size,
662 [ + - ]: 2800 : &result );
663 [ - + ][ # # ]: 2800 : ASSERT( iBase_SUCCESS == result );
664 [ - + ]: 2800 : if( !assert_pass )
665 : : {
666 : 0 : free( entities );
667 : 0 : free( adj_ents );
668 : 0 : free( indices );
669 : 0 : free( offsets );
670 : 0 : return FALSE;
671 : : }
672 : :
673 [ - + ][ # # ]: 2800 : ASSERT( adj_ents2_ptr == adj_ents2 ); /* shouldn't change */
674 [ - + ]: 2800 : if( !assert_pass )
675 : : {
676 : 0 : free( entities );
677 : 0 : free( adj_ents );
678 : 0 : free( indices );
679 : 0 : free( offsets );
680 : 0 : return FALSE;
681 : : }
682 : :
683 [ - + ][ # # ]: 2800 : ASSERT( adj_ents2_alloc == 27 ); /* shouldn't change */
684 [ - + ]: 2800 : if( !assert_pass )
685 : : {
686 : 0 : free( entities );
687 : 0 : free( adj_ents );
688 : 0 : free( indices );
689 : 0 : free( offsets );
690 : 0 : return FALSE;
691 : : }
692 : :
693 : : /* compare results */
694 : 2800 : size = offsets[i + 1] - offsets[i];
695 [ - + ][ # # ]: 2800 : ASSERT( size == adj_ents2_size );
696 [ + + ]: 15600 : while( --size >= 0 )
697 : : {
698 [ - + ][ # # ]: 12800 : ASSERT( adj_ents2[size] == adj_ents[indices[offsets[i] + size]] );
699 [ - + ]: 12800 : if( !assert_pass )
700 : : {
701 : 0 : free( entities );
702 : 0 : free( adj_ents );
703 : 0 : free( indices );
704 : 0 : free( offsets );
705 : 0 : return FALSE;
706 : : }
707 : : }
708 : : }
709 : :
710 : 3 : free( entities );
711 : 3 : free( adj_ents );
712 : 3 : free( indices );
713 : 3 : free( offsets );
714 : :
715 : : /*
716 : : offsets = NULL;
717 : : offsets_alloc = 0;
718 : : entities = NULL;
719 : : entities_alloc = 0;
720 : :
721 : : iMesh_getAdjEntities(mesh, root_set, type,
722 : : iMesh_ALL_TOPOLOGIES, iBase_VERTEX,
723 : : &entities, &entities_alloc, &entities_size,
724 : : &offsets, &offsets_alloc, &offsets_size,
725 : : &result);
726 : : if (iBase_SUCCESS != result) {
727 : : printf("Failed to get indices of adjacent entity vertices in connectivity_test.\n");
728 : : return FALSE;
729 : : }
730 : :
731 : : if (entities_alloc != entities_size ||
732 : : offsets_alloc != offsets_size) {
733 : : printf("Number of elements didn't agree with array size for an array in
734 : : connectivity_test.\n"); return FALSE;
735 : : }
736 : :
737 : : free(offsets);
738 : : free(entities);
739 : : */
740 : : }
741 : :
742 : 1 : return TRUE;
743 : : }
744 : :
745 : : /*!
746 : : @test
747 : : TSTT entity sets sub test
748 : : @li Check entity sets
749 : : */
750 : :
751 : : /* helper function used to report errors in # sets */
752 : : int check_esets( iMesh_Instance mesh, const int num_sets );
753 : :
754 : 2 : int entity_sets_subtest( iMesh_Instance mesh, int is_list, int /*num_iter*/ )
755 : : {
756 : 2 : int i, num_type = iBase_ALL_TYPES - iBase_VERTEX;
757 : : // int num_all_entities_super = 0;
758 : : iBase_EntitySetHandle es_array[iBase_ALL_TYPES - iBase_VERTEX];
759 : : int number_array[iBase_ALL_TYPES - iBase_VERTEX];
760 : 2 : int ent_type = iBase_VERTEX;
761 : 2 : iBase_EntityHandle* entities = NULL;
762 : 2 : int entities_alloc = 0, entities_size;
763 : 2 : iBase_EntitySetHandle parent_child, super_set = NULL;
764 : : iBase_EntitySetHandle temp_es1, temp_es2, temp_es3;
765 : 2 : iBase_EntityHandle *edges = NULL, *faces = NULL, *temp_entities1 = NULL, *temp_entities2 = NULL;
766 : 2 : int edges_alloc = 0, faces_alloc = 0, temp_entities1_alloc = 0, temp_entities2_alloc = 0;
767 : : int edges_size, faces_size, temp_entities1_size, temp_entities2_size;
768 : 2 : int* types = NULL;
769 : 2 : int types_alloc = 0, types_size;
770 : : int num_rest, num_regions;
771 : 2 : iBase_EntityHandle* regions = NULL;
772 : 2 : int regions_alloc = 0, regions_size;
773 : 2 : iBase_EntitySetHandle* parents = NULL;
774 : 2 : int parents_alloc = 0, parents_size, temp_numb, is_child;
775 : 2 : iBase_EntitySetHandle* es_array1 = NULL;
776 : 2 : int es_array1_alloc = 0, es_array1_size, num_super;
777 : 2 : iBase_EntityHandle* all_entities = NULL;
778 : 2 : int all_entities_alloc = 0, all_entities_size, k, l;
779 : 2 : iBase_EntityHandle* adj_faces = NULL;
780 : 2 : int adj_faces_alloc = 0, adj_faces_size;
781 : 2 : int* face_offsets = NULL;
782 : 2 : int face_offsets_alloc = 0, face_offsets_size;
783 : 2 : iBase_EntityHandle* hexes = NULL;
784 : 2 : int hexes_alloc = 0, hexes_size;
785 : : iBase_EntitySetHandle hex_set;
786 : :
787 : : /* get the number of whole mesh */
788 : 2 : int n_whole_mesh = 0;
789 : : int result;
790 [ + - ]: 2 : iMesh_getNumEntSets( mesh, root_set, 1, &n_whole_mesh, &result );
791 [ - + ]: 2 : if( iBase_SUCCESS != result )
792 : : {
793 [ # # ]: 0 : printf( "Problem to get the number of all entity sets in whole mesh.\n" );
794 : 0 : return FALSE;
795 : : }
796 : :
797 : : /* add entities to entitysets by type */
798 [ + + ]: 10 : for( ; ent_type < num_type; ent_type++ )
799 : : {
800 : : /* initialize the entityset */
801 [ + - ]: 8 : iMesh_createEntSet( mesh, is_list, &es_array[ent_type], &result );
802 [ - + ]: 8 : if( iBase_SUCCESS != result )
803 : : {
804 [ # # ]: 0 : printf( "Problem creating entityset.\n" );
805 : 0 : return FALSE;
806 : : }
807 : :
808 : : /* get entities by type in total "mesh" */
809 : 8 : entities = NULL;
810 : 8 : entities_alloc = 0;
811 : : iMesh_getEntities( mesh, root_set, ent_type, iMesh_ALL_TOPOLOGIES, &entities, &entities_alloc, &entities_size,
812 [ + - ]: 8 : &result );
813 [ - + ]: 8 : if( iBase_SUCCESS != result )
814 : : {
815 [ # # ]: 0 : printf( "Failed to get entities by type in entity_sets_test.\n" );
816 : 0 : return FALSE;
817 : : }
818 : :
819 [ - + ]: 8 : if( entities_alloc != entities_size )
820 : : {
821 [ # # ]: 0 : printf( "Number of entities didn't agree with array size in entity_sets_subtest.\n" );
822 : 0 : free( entities );
823 : 0 : return FALSE;
824 : : }
825 : :
826 : : /* add entities into entity set */
827 [ + - ]: 8 : if( 0 != entities_size )
828 : : {
829 [ + - ]: 8 : iMesh_addEntArrToSet( mesh, entities, entities_size, es_array[ent_type], &result );
830 [ - + ]: 8 : if( iBase_SUCCESS != result )
831 : : {
832 [ # # ]: 0 : printf( "Failed to add entities in entity_sets_test.\n" );
833 : 0 : free( entities );
834 : 0 : return FALSE;
835 : : }
836 : : }
837 : :
838 : : /* Check to make sure entity set really has correct number of entities in it */
839 [ + - ]: 8 : iMesh_getNumOfType( mesh, es_array[ent_type], ent_type, number_array + ent_type, &result );
840 : :
841 [ - + ]: 8 : if( iBase_SUCCESS != result )
842 : : {
843 [ # # ]: 0 : printf( "Failed to get number of entities by type in entity_sets_test.\n" );
844 : 0 : free( entities );
845 : 0 : return FALSE;
846 : : }
847 : :
848 : : /* compare the number of entities by type */
849 [ - + ]: 8 : if( number_array[ent_type] != entities_size )
850 : : {
851 [ # # ]: 0 : printf( "Number of entities by type is not correct\n" );
852 : 0 : free( entities );
853 : 0 : return FALSE;
854 : : }
855 : :
856 : : /* add to number of all entities in super set */
857 : : // num_all_entities_super += entities_size;
858 : :
859 : 8 : free( entities );
860 : : }
861 : :
862 [ + - ][ - + ]: 2 : if( !check_esets( mesh, n_whole_mesh + num_type ) ) return FALSE;
863 : :
864 : : /* make a super set having all entitysets */
865 : 2 : super_set = NULL;
866 [ + - ]: 2 : iMesh_createEntSet( mesh, is_list, &super_set, &result );
867 [ - + ]: 2 : if( iBase_SUCCESS != result )
868 : : {
869 [ # # ]: 0 : printf( "Failed to create a super set in entity_sets_test.\n" );
870 : 0 : return FALSE;
871 : : }
872 : :
873 [ + + ]: 10 : for( i = 0; i < num_type; i++ )
874 : : {
875 [ + - ]: 8 : iMesh_addEntSet( mesh, es_array[i], super_set, &result );
876 [ - + ]: 8 : if( iBase_SUCCESS != result )
877 : : {
878 [ # # ]: 0 : printf( "Failed to add a set to a super set in entity_sets_test.\n" );
879 : 0 : return FALSE;
880 : : }
881 : : }
882 : :
883 [ + - ][ - + ]: 2 : if( !check_esets( mesh, n_whole_mesh + num_type + 1 ) ) return FALSE;
884 : :
885 : : /*----------TEST intEAN OPERATIONS----------------*/
886 : :
887 [ + - ]: 2 : iMesh_createEntSet( mesh, is_list, &temp_es1, &result );
888 [ - + ]: 2 : if( iBase_SUCCESS != result )
889 : : {
890 [ # # ]: 0 : printf( "Failed to create a super set in entity_sets_test.\n" );
891 : 0 : return FALSE;
892 : : }
893 : :
894 [ + - ][ - + ]: 2 : if( !check_esets( mesh, n_whole_mesh + num_type + 2 ) ) { return FALSE; }
895 : :
896 : : /* Subtract */
897 : : /* add all EDGEs and FACEs to temp_es1 */
898 : : /* get all EDGE entities */
899 : 2 : edges = NULL;
900 : 2 : edges_alloc = 0;
901 : : iMesh_getEntities( mesh, es_array[iBase_EDGE], iBase_EDGE, iMesh_ALL_TOPOLOGIES, &edges, &edges_alloc, &edges_size,
902 [ + - ]: 2 : &result );
903 : :
904 [ - + ]: 2 : if( iBase_SUCCESS != result )
905 : : {
906 [ # # ]: 0 : printf( "Failed to get edge entities in entity_sets_test.\n" );
907 : 0 : return FALSE;
908 : : }
909 : :
910 : : /* add EDGEs to es1 */
911 [ + - ]: 2 : iMesh_addEntArrToSet( mesh, edges, edges_size, temp_es1, &result );
912 [ - + ]: 2 : if( iBase_SUCCESS != result )
913 : : {
914 [ # # ]: 0 : printf( "Failed to add edge entities in entity_sets_test.\n" );
915 : 0 : free( edges );
916 : 0 : return FALSE;
917 : : }
918 : :
919 : : /* get all FACE entities */
920 : 2 : faces = NULL;
921 : 2 : faces_alloc = 0;
922 : : iMesh_getEntities( mesh, es_array[iBase_FACE], iBase_FACE, iMesh_ALL_TOPOLOGIES, &faces, &faces_alloc, &faces_size,
923 [ + - ]: 2 : &result );
924 [ - + ]: 2 : if( iBase_SUCCESS != result )
925 : : {
926 [ # # ]: 0 : printf( "Failed to get face entities in entity_sets_test.\n" );
927 : 0 : free( edges );
928 : 0 : return FALSE;
929 : : }
930 : :
931 : : /* add FACEs to es1 */
932 [ + - ]: 2 : iMesh_addEntArrToSet( mesh, faces, faces_size, temp_es1, &result );
933 [ - + ]: 2 : if( iBase_SUCCESS != result )
934 : : {
935 [ # # ]: 0 : printf( "Failed to add face entities in entity_sets_test.\n" );
936 : 0 : free( edges );
937 : 0 : free( faces );
938 : 0 : return FALSE;
939 : : }
940 : :
941 : : /* subtract EDGEs */
942 : :
943 [ + - ]: 2 : iMesh_subtract( mesh, temp_es1, es_array[iBase_EDGE], &temp_es2, &result );
944 [ - + ]: 2 : if( iBase_SUCCESS != result )
945 : : {
946 [ # # ]: 0 : printf( "Failed to subtract entitysets in entity_sets_test.\n" );
947 : 0 : free( edges );
948 : 0 : free( faces );
949 : 0 : return FALSE;
950 : : }
951 : :
952 : 2 : temp_entities1 = NULL;
953 : 2 : temp_entities1_alloc = 0;
954 : : iMesh_getEntities( mesh, temp_es2, iBase_FACE, iMesh_ALL_TOPOLOGIES, &temp_entities1, &temp_entities1_alloc,
955 [ + - ]: 2 : &temp_entities1_size, &result );
956 [ - + ]: 2 : if( iBase_SUCCESS != result )
957 : : {
958 [ # # ]: 0 : printf( "Failed to get face entities in entity_sets_test.\n" );
959 : 0 : free( edges );
960 : 0 : free( faces );
961 : 0 : return FALSE;
962 : : }
963 : :
964 [ - + ]: 2 : if( faces_size != temp_entities1_size )
965 : : {
966 : : printf( "not match number of entitysets after subtraction "
967 [ # # ]: 0 : "in entity_sets_test.\n" );
968 : 0 : free( edges );
969 : 0 : free( faces );
970 : 0 : free( temp_entities1 );
971 : 0 : return FALSE;
972 : : }
973 : :
974 : : /* check there's nothing but faces in face_es */
975 : 2 : types = NULL;
976 : 2 : types_alloc = 0;
977 [ + - ]: 2 : iMesh_getEntArrType( mesh, temp_entities1, temp_entities1_size, &types, &types_alloc, &types_size, &result );
978 [ - + ]: 2 : if( iBase_SUCCESS != result )
979 : : {
980 [ # # ]: 0 : printf( "Failed to get types of entities in entity_sets_test.\n" );
981 : 0 : free( edges );
982 : 0 : free( faces );
983 : 0 : free( temp_entities1 );
984 : 0 : return FALSE;
985 : : }
986 [ + + ]: 1202 : for( i = 0; i < types_size; i++ )
987 : : {
988 [ - + ]: 1200 : if( types[i] != iBase_FACE )
989 : : {
990 [ # # ]: 0 : printf( "wrong entity type for face test in entity_sets_test.\n" );
991 : 0 : free( edges );
992 : 0 : free( faces );
993 : 0 : free( temp_entities1 );
994 : 0 : free( types );
995 : 0 : return FALSE;
996 : : }
997 : : }
998 : :
999 [ + - ]: 2 : iMesh_destroyEntSet( mesh, temp_es2, &result );
1000 [ - + ]: 2 : if( iBase_SUCCESS != result )
1001 : : {
1002 [ # # ]: 0 : printf( "Failed to destroy temp es2.\n" );
1003 : 0 : free( edges );
1004 : 0 : free( faces );
1005 : 0 : free( temp_entities1 );
1006 : 0 : free( types );
1007 : 0 : return FALSE;
1008 : : }
1009 : :
1010 [ + - ][ - + ]: 2 : if( !check_esets( mesh, n_whole_mesh + num_type + 2 ) )
1011 : : {
1012 : 0 : free( edges );
1013 : 0 : free( faces );
1014 : 0 : free( temp_entities1 );
1015 : 0 : free( types );
1016 : 0 : return FALSE;
1017 : : }
1018 : :
1019 : : /*------------Intersect------------ */
1020 : :
1021 : : /* clean out the temp_ms1 */
1022 [ + - ]: 2 : iMesh_rmvEntArrFromSet( mesh, faces, faces_size, temp_es1, &result );
1023 [ - + ]: 2 : if( iBase_SUCCESS != result )
1024 : : {
1025 [ # # ]: 0 : printf( "Failed to remove face entities in entity_sets_test.\n" );
1026 : 0 : free( edges );
1027 : 0 : free( faces );
1028 : 0 : free( temp_entities1 );
1029 : 0 : free( types );
1030 : 0 : return FALSE;
1031 : : }
1032 : :
1033 : : /* check if it is really cleaned out */
1034 [ + - ]: 2 : iMesh_getNumOfType( mesh, temp_es1, iBase_FACE, &num_rest, &result );
1035 [ - + ]: 2 : if( iBase_SUCCESS != result )
1036 : : {
1037 [ # # ]: 0 : printf( "Failed to get number of entities by type in entity_sets_test.\n" );
1038 : 0 : free( edges );
1039 : 0 : free( faces );
1040 : 0 : free( temp_entities1 );
1041 : 0 : free( types );
1042 : 0 : return FALSE;
1043 : : }
1044 : :
1045 [ - + ]: 2 : if( num_rest != 0 )
1046 : : {
1047 [ # # ]: 0 : printf( "failed to remove correctly.\n" );
1048 : 0 : free( edges );
1049 : 0 : free( faces );
1050 : 0 : free( temp_entities1 );
1051 : 0 : free( types );
1052 : 0 : return FALSE;
1053 : : }
1054 : :
1055 : : /* add EDGEs to temp es1 */
1056 [ + - ]: 2 : iMesh_addEntArrToSet( mesh, edges, edges_size, temp_es1, &result );
1057 [ - + ]: 2 : if( iBase_SUCCESS != result )
1058 : : {
1059 [ # # ]: 0 : printf( "Failed to add edge entities in entity_sets_test.\n" );
1060 : 0 : free( edges );
1061 : 0 : free( faces );
1062 : 0 : free( temp_entities1 );
1063 : 0 : free( types );
1064 : 0 : return FALSE;
1065 : : }
1066 : :
1067 : : /* add FACEs to temp es1 */
1068 [ + - ]: 2 : iMesh_addEntArrToSet( mesh, faces, faces_size, temp_es1, &result );
1069 [ - + ]: 2 : if( iBase_SUCCESS != result )
1070 : : {
1071 [ # # ]: 0 : printf( "Failed to add edge entities in entity_sets_test.\n" );
1072 : 0 : free( edges );
1073 : 0 : free( faces );
1074 : 0 : free( temp_entities1 );
1075 : 0 : free( types );
1076 : 0 : return FALSE;
1077 : : }
1078 : :
1079 : : /* intersect temp_es1 with edges meshset */
1080 : : /* temp_ms1 entityset is altered */
1081 [ + - ]: 2 : iMesh_intersect( mesh, temp_es1, es_array[iBase_EDGE], &temp_es2, &result );
1082 [ - + ]: 2 : if( iBase_SUCCESS != result )
1083 : : {
1084 [ # # ]: 0 : printf( "Failed to intersect in entity_sets_test.\n" );
1085 : 0 : free( edges );
1086 : 0 : free( faces );
1087 : 0 : free( temp_entities1 );
1088 : 0 : free( types );
1089 : 0 : return FALSE;
1090 : : }
1091 : :
1092 : 2 : temp_entities2 = NULL;
1093 : 2 : temp_entities2_alloc = 0;
1094 : : iMesh_getEntities( mesh, temp_es2, iBase_FACE, iMesh_ALL_TOPOLOGIES, &temp_entities2, &temp_entities2_alloc,
1095 [ + - ]: 2 : &temp_entities2_size, &result );
1096 [ - + ]: 2 : if( iBase_SUCCESS != result )
1097 : : {
1098 [ # # ]: 0 : printf( "Failed to get face entities in entity_sets_test.\n" );
1099 : 0 : free( edges );
1100 : 0 : free( faces );
1101 : 0 : free( temp_entities1 );
1102 : 0 : free( types );
1103 : 0 : return FALSE;
1104 : : }
1105 : :
1106 [ - + ]: 2 : if( temp_entities2_size != 0 )
1107 : : {
1108 [ # # ]: 0 : printf( "wrong number of faces.\n" );
1109 : 0 : free( edges );
1110 : 0 : free( faces );
1111 : 0 : free( temp_entities1 );
1112 : 0 : free( temp_entities2 );
1113 : 0 : free( types );
1114 : 0 : return FALSE;
1115 : : }
1116 : :
1117 [ + - ]: 2 : iMesh_destroyEntSet( mesh, temp_es2, &result );
1118 [ - + ]: 2 : if( iBase_SUCCESS != result )
1119 : : {
1120 [ # # ]: 0 : printf( "Failed to destroy temp es2.\n" );
1121 : 0 : free( edges );
1122 : 0 : free( faces );
1123 : 0 : free( temp_entities1 );
1124 : 0 : free( temp_entities2 );
1125 : 0 : free( types );
1126 : 0 : return FALSE;
1127 : : }
1128 : :
1129 [ + - ][ - + ]: 2 : if( !check_esets( mesh, n_whole_mesh + num_type + 2 ) )
1130 : : {
1131 : 0 : free( edges );
1132 : 0 : free( faces );
1133 : 0 : free( temp_entities1 );
1134 : 0 : free( temp_entities2 );
1135 : 0 : free( types );
1136 : 0 : return FALSE;
1137 : : }
1138 : :
1139 : : /*-------------Unite-------------- */
1140 : :
1141 [ + - ]: 2 : iMesh_createEntSet( mesh, is_list, &temp_es2, &result );
1142 [ - + ]: 2 : if( iBase_SUCCESS != result )
1143 : : {
1144 [ # # ]: 0 : printf( "Failed to create a temp entityset in entity_sets_test.\n" );
1145 : 0 : free( edges );
1146 : 0 : free( faces );
1147 : 0 : free( temp_entities1 );
1148 : 0 : free( temp_entities2 );
1149 : 0 : free( types );
1150 : 0 : return FALSE;
1151 : : }
1152 : :
1153 : : /* get all regions */
1154 : 2 : regions = NULL;
1155 : 2 : regions_alloc = 0;
1156 : : iMesh_getEntities( mesh, es_array[iBase_REGION], iBase_REGION, iMesh_ALL_TOPOLOGIES, ®ions, ®ions_alloc,
1157 [ + - ]: 2 : ®ions_size, &result );
1158 [ - + ]: 2 : if( iBase_SUCCESS != result )
1159 : : {
1160 [ # # ]: 0 : printf( "Failed to get region entities in entity_sets_test.\n" );
1161 : 0 : free( edges );
1162 : 0 : free( faces );
1163 : 0 : free( temp_entities1 );
1164 : 0 : free( temp_entities2 );
1165 : 0 : free( types );
1166 : 0 : return FALSE;
1167 : : }
1168 : :
1169 : : /* add REGIONs to temp es2 */
1170 [ + - ]: 2 : iMesh_addEntArrToSet( mesh, regions, regions_size, temp_es2, &result );
1171 [ - + ]: 2 : if( iBase_SUCCESS != result )
1172 : : {
1173 [ # # ]: 0 : printf( "Failed to add region entities in entity_sets_test.\n" );
1174 : 0 : free( edges );
1175 : 0 : free( faces );
1176 : 0 : free( temp_entities1 );
1177 : 0 : free( temp_entities2 );
1178 : 0 : free( types );
1179 : 0 : free( regions );
1180 : 0 : return FALSE;
1181 : : }
1182 : :
1183 : : /* unite temp_es1 and temp_es2 */
1184 [ + - ]: 2 : iMesh_unite( mesh, temp_es1, temp_es2, &temp_es3, &result );
1185 [ - + ]: 2 : if( iBase_SUCCESS != result )
1186 : : {
1187 [ # # ]: 0 : printf( "Failed to unite in entity_sets_test.\n" );
1188 : 0 : free( edges );
1189 : 0 : free( faces );
1190 : 0 : free( temp_entities1 );
1191 : 0 : free( temp_entities2 );
1192 : 0 : free( types );
1193 : 0 : free( regions );
1194 : 0 : return FALSE;
1195 : : }
1196 : :
1197 : : /* perform the check */
1198 [ + - ]: 2 : iMesh_getNumOfType( mesh, temp_es3, iBase_REGION, &num_regions, &result );
1199 [ - + ]: 2 : if( iBase_SUCCESS != result )
1200 : : {
1201 [ # # ]: 0 : printf( "Failed to get number of region entities by type in entity_sets_test.\n" );
1202 : 0 : free( edges );
1203 : 0 : free( faces );
1204 : 0 : free( temp_entities1 );
1205 : 0 : free( temp_entities2 );
1206 : 0 : free( types );
1207 : 0 : free( regions );
1208 : 0 : return FALSE;
1209 : : }
1210 : :
1211 [ - + ]: 2 : if( num_regions != number_array[iBase_REGION] )
1212 : : {
1213 [ # # ]: 0 : printf( "different number of regions in entity_sets_test.\n" );
1214 : 0 : free( edges );
1215 : 0 : free( faces );
1216 : 0 : free( temp_entities1 );
1217 : 0 : free( temp_entities2 );
1218 : 0 : free( types );
1219 : 0 : free( regions );
1220 : 0 : return FALSE;
1221 : : }
1222 : :
1223 [ + - ][ - + ]: 2 : if( !check_esets( mesh, n_whole_mesh + num_type + 4 ) )
1224 : : {
1225 : 0 : free( edges );
1226 : 0 : free( faces );
1227 : 0 : free( temp_entities1 );
1228 : 0 : free( temp_entities2 );
1229 : 0 : free( types );
1230 : 0 : free( regions );
1231 : 0 : return FALSE;
1232 : : }
1233 : :
1234 : : /*--------Test parent/child stuff in entiysets----------- */
1235 : :
1236 : : /* Add 2 meshsets as children to another */
1237 [ + - ]: 2 : iMesh_createEntSet( mesh, is_list, &parent_child, &result );
1238 [ - + ]: 2 : if( iBase_SUCCESS != result )
1239 : : {
1240 [ # # ]: 0 : printf( "Problem creating entityset in entity_sets_test.\n" );
1241 : 0 : free( edges );
1242 : 0 : free( faces );
1243 : 0 : free( temp_entities1 );
1244 : 0 : free( temp_entities2 );
1245 : 0 : free( types );
1246 : 0 : free( regions );
1247 : 0 : return FALSE;
1248 : : }
1249 : :
1250 [ + - ]: 2 : iMesh_addPrntChld( mesh, es_array[iBase_VERTEX], parent_child, &result );
1251 [ - + ]: 2 : if( iBase_SUCCESS != result )
1252 : : {
1253 [ # # ]: 0 : printf( "Problem add parent in entity_sets_test.\n" );
1254 : 0 : free( edges );
1255 : 0 : free( faces );
1256 : 0 : free( temp_entities1 );
1257 : 0 : free( temp_entities2 );
1258 : 0 : free( types );
1259 : 0 : free( regions );
1260 : 0 : return FALSE;
1261 : : }
1262 : :
1263 : : /* check if parent is really added */
1264 : 2 : parents = NULL;
1265 : 2 : parents_alloc = 0;
1266 [ + - ]: 2 : iMesh_getPrnts( mesh, parent_child, 0, &parents, &parents_alloc, &parents_size, &result );
1267 [ - + ]: 2 : if( iBase_SUCCESS != result )
1268 : : {
1269 [ # # ]: 0 : printf( "Problem getting parents in entity_sets_test.\n" );
1270 : 0 : free( edges );
1271 : 0 : free( faces );
1272 : 0 : free( temp_entities1 );
1273 : 0 : free( temp_entities2 );
1274 : 0 : free( types );
1275 : 0 : free( regions );
1276 : 0 : return FALSE;
1277 : : }
1278 : :
1279 [ - + ]: 2 : if( parents_size != 1 )
1280 : : {
1281 [ # # ]: 0 : printf( "number of parents is not correct in entity_sets_test.\n" );
1282 : 0 : free( edges );
1283 : 0 : free( faces );
1284 : 0 : free( temp_entities1 );
1285 : 0 : free( temp_entities2 );
1286 : 0 : free( types );
1287 : 0 : free( regions );
1288 : 0 : free( parents );
1289 : 0 : return FALSE;
1290 : : }
1291 : :
1292 : : /* get the number of child entitysets */
1293 [ + - ]: 2 : iMesh_getNumChld( mesh, es_array[iBase_VERTEX], 0, &temp_numb, &result );
1294 [ - + ]: 2 : if( iBase_SUCCESS != result )
1295 : : {
1296 [ # # ]: 0 : printf( "Problem getting number of children in entity_sets_test.\n" );
1297 : 0 : free( edges );
1298 : 0 : free( faces );
1299 : 0 : free( temp_entities1 );
1300 : 0 : free( temp_entities2 );
1301 : 0 : free( types );
1302 : 0 : free( regions );
1303 : 0 : free( parents );
1304 : 0 : return FALSE;
1305 : : }
1306 : :
1307 [ - + ]: 2 : if( temp_numb != 1 )
1308 : : {
1309 [ # # ]: 0 : printf( "number of children is not correct in entity_sets_test.\n" );
1310 : 0 : free( edges );
1311 : 0 : free( faces );
1312 : 0 : free( temp_entities1 );
1313 : 0 : free( temp_entities2 );
1314 : 0 : free( types );
1315 : 0 : free( regions );
1316 : 0 : free( parents );
1317 : 0 : return FALSE;
1318 : : }
1319 : :
1320 : : /* parent_child and es_array[iBase_VERTEX] should be related */
1321 : 2 : is_child = 0;
1322 [ + - ]: 2 : iMesh_isChildOf( mesh, es_array[iBase_VERTEX], parent_child, &is_child, &result );
1323 [ - + ]: 2 : if( iBase_SUCCESS != result )
1324 : : {
1325 [ # # ]: 0 : printf( "Problem checking relation in entity_sets_test.\n" );
1326 : 0 : free( edges );
1327 : 0 : free( faces );
1328 : 0 : free( temp_entities1 );
1329 : 0 : free( temp_entities2 );
1330 : 0 : free( types );
1331 : 0 : free( regions );
1332 : 0 : free( parents );
1333 : 0 : return FALSE;
1334 : : }
1335 [ - + ]: 2 : if( !is_child )
1336 : : {
1337 [ # # ]: 0 : printf( "parent_child and es_array[iBase_VERTEX] should be related\n" );
1338 : 0 : free( edges );
1339 : 0 : free( faces );
1340 : 0 : free( temp_entities1 );
1341 : 0 : free( temp_entities2 );
1342 : 0 : free( types );
1343 : 0 : free( regions );
1344 : 0 : free( parents );
1345 : 0 : return FALSE;
1346 : : }
1347 : :
1348 : : /* es_array[iBase_FACE] and es_array[iBase_REGION] are not related */
1349 : 2 : is_child = FALSE;
1350 [ + - ]: 2 : iMesh_isChildOf( mesh, es_array[iBase_FACE], es_array[iBase_REGION], &is_child, &result );
1351 [ - + ]: 2 : if( iBase_SUCCESS != result )
1352 : : {
1353 [ # # ]: 0 : printf( "Problem checking relation in entity_sets_test.\n" );
1354 : 0 : free( edges );
1355 : 0 : free( faces );
1356 : 0 : free( temp_entities1 );
1357 : 0 : free( temp_entities2 );
1358 : 0 : free( types );
1359 : 0 : free( regions );
1360 : 0 : free( parents );
1361 : 0 : return FALSE;
1362 : : }
1363 [ - + ]: 2 : if( is_child )
1364 : : {
1365 [ # # ]: 0 : printf( "es_array[iBase_REGION] and es_array[iBase_FACE] should not be related\n" );
1366 : 0 : free( edges );
1367 : 0 : free( faces );
1368 : 0 : free( temp_entities1 );
1369 : 0 : free( temp_entities2 );
1370 : 0 : free( types );
1371 : 0 : free( regions );
1372 : 0 : free( parents );
1373 : 0 : return FALSE;
1374 : : }
1375 : :
1376 [ + - ][ - + ]: 2 : if( !check_esets( mesh, n_whole_mesh + num_type + 5 ) )
1377 : : {
1378 : 0 : free( edges );
1379 : 0 : free( faces );
1380 : 0 : free( temp_entities1 );
1381 : 0 : free( temp_entities2 );
1382 : 0 : free( types );
1383 : 0 : free( regions );
1384 : 0 : free( parents );
1385 : 0 : return FALSE;
1386 : : }
1387 : :
1388 : : /*--------test modify and query functions----------------------------- */
1389 : :
1390 : : /* get all entity sets in super set */
1391 : 2 : es_array1 = NULL;
1392 : 2 : es_array1_alloc = 0;
1393 [ + - ]: 2 : iMesh_getEntSets( mesh, super_set, 0, &es_array1, &es_array1_alloc, &es_array1_size, &result );
1394 [ - + ]: 2 : if( iBase_SUCCESS != result )
1395 : : {
1396 [ # # ]: 0 : printf( "Problem to get entity sets in super set.\n" );
1397 : 0 : free( edges );
1398 : 0 : free( faces );
1399 : 0 : free( temp_entities1 );
1400 : 0 : free( temp_entities2 );
1401 : 0 : free( types );
1402 : 0 : free( regions );
1403 : 0 : free( parents );
1404 : 0 : return FALSE;
1405 : : }
1406 : :
1407 : : /* get the number of entity sets in super set */
1408 [ + - ]: 2 : iMesh_getNumEntSets( mesh, super_set, 0, &num_super, &result );
1409 [ - + ]: 2 : if( iBase_SUCCESS != result )
1410 : : {
1411 [ # # ]: 0 : printf( "Problem to get the number of all entity sets in super set.\n" );
1412 : 0 : free( edges );
1413 : 0 : free( faces );
1414 : 0 : free( temp_entities1 );
1415 : 0 : free( temp_entities2 );
1416 : 0 : free( types );
1417 : 0 : free( regions );
1418 : 0 : free( parents );
1419 : 0 : free( es_array1 );
1420 : 0 : return FALSE;
1421 : : }
1422 : :
1423 : : /* the number of entity sets in super set should be same */
1424 [ - + ]: 2 : if( num_super != es_array1_size )
1425 : : {
1426 [ # # ]: 0 : printf( "the number of entity sets in super set should be same.\n" );
1427 : 0 : return FALSE;
1428 : : }
1429 : :
1430 : : /* get all entities in super set */
1431 : 2 : all_entities = NULL;
1432 : 2 : all_entities_alloc = 0;
1433 : : iMesh_getEntities( mesh, super_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &all_entities, &all_entities_alloc,
1434 [ + - ]: 2 : &all_entities_size, &result );
1435 [ - + ]: 2 : if( iBase_SUCCESS != result )
1436 : : {
1437 [ # # ]: 0 : printf( "Problem to get all entities in super set.\n" );
1438 : 0 : free( edges );
1439 : 0 : free( faces );
1440 : 0 : free( temp_entities1 );
1441 : 0 : free( temp_entities2 );
1442 : 0 : free( types );
1443 : 0 : free( regions );
1444 : 0 : free( parents );
1445 : 0 : free( es_array1 );
1446 : 0 : return FALSE;
1447 : : }
1448 : :
1449 : : /* compare the number of all entities in super set */
1450 : : /* NOTE: TEST COMMENTED OUT UNTIL RESOLUTION OF WHETHER GETENTITIES */
1451 : : /* SHOULD GET A NUM_HOPS ARGUMENT */
1452 : : /* if (num_all_entities_super != all_entities_size) { */
1453 : : /* printf("number of all entities in super set should be same.\n"); */
1454 : : /* return FALSE; */
1455 : : /* } */
1456 : :
1457 : : /* test add, remove and get all entity sets using super set */
1458 : : /* check GetAllEntitySets works recursively and dosen't return */
1459 : : /* multi sets */
1460 [ + + ]: 10 : for( k = 0; k < num_super; k++ )
1461 : : {
1462 : : /* add entity sets of super set to each entity set of super set */
1463 : : /* make multiple child super sets */
1464 : 8 : iBase_EntitySetHandle es_k = es_array1[k];
1465 [ + + ]: 40 : for( l = 0; l < es_array1_size; l++ )
1466 : : {
1467 [ + - ]: 32 : iMesh_addEntSet( mesh, es_array1[l], es_k, &result );
1468 [ - + ]: 32 : if( iBase_SUCCESS != result )
1469 : : {
1470 [ # # ]: 0 : printf( "Problem to add entity set to entityset.\n" );
1471 : 0 : free( edges );
1472 : 0 : free( faces );
1473 : 0 : free( temp_entities1 );
1474 : 0 : free( temp_entities2 );
1475 : 0 : free( types );
1476 : 0 : free( regions );
1477 : 0 : free( parents );
1478 : 0 : free( es_array1 );
1479 : 0 : free( all_entities );
1480 : 0 : return FALSE;
1481 : : }
1482 : : }
1483 : :
1484 : : /* add super set to each entity set */
1485 [ + - ]: 8 : iMesh_addEntSet( mesh, super_set, es_k, &result );
1486 [ - + ]: 8 : if( iBase_SUCCESS != result )
1487 : : {
1488 [ # # ]: 0 : printf( "Problem to add super set to entitysets.\n" );
1489 : 0 : free( edges );
1490 : 0 : free( faces );
1491 : 0 : free( temp_entities1 );
1492 : 0 : free( temp_entities2 );
1493 : 0 : free( types );
1494 : 0 : free( regions );
1495 : 0 : free( parents );
1496 : 0 : free( es_array1 );
1497 : 0 : free( all_entities );
1498 : 0 : return FALSE;
1499 : : }
1500 : :
1501 : : /* add one entity sets multiple times */
1502 [ + + ]: 32 : for( l = 0; l < 3; l++ )
1503 : : {
1504 [ + - ]: 24 : iMesh_addEntSet( mesh, temp_es1, es_k, &result );
1505 [ - + ]: 24 : if( iBase_SUCCESS != result )
1506 : : {
1507 [ # # ]: 0 : printf( "Problem to add temp set to entitysets.\n" );
1508 : 0 : free( edges );
1509 : 0 : free( faces );
1510 : 0 : free( temp_entities1 );
1511 : 0 : free( temp_entities2 );
1512 : 0 : free( types );
1513 : 0 : free( regions );
1514 : 0 : free( parents );
1515 : 0 : free( es_array1 );
1516 : 0 : free( all_entities );
1517 : 0 : return FALSE;
1518 : : }
1519 : : }
1520 : : }
1521 : :
1522 : : /* get all hexes and get faces of that hexes */
1523 : 2 : hexes = NULL;
1524 : 2 : hexes_alloc = 0;
1525 : :
1526 [ + - ]: 2 : iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_HEXAHEDRON, &hexes, &hexes_alloc, &hexes_size, &result );
1527 [ - + ]: 2 : if( iBase_SUCCESS != result )
1528 : : {
1529 [ # # ]: 0 : printf( "Failed to get hexes in entity_sets_test.\n" );
1530 : 0 : free( edges );
1531 : 0 : free( faces );
1532 : 0 : free( temp_entities1 );
1533 : 0 : free( temp_entities2 );
1534 : 0 : free( types );
1535 : 0 : free( regions );
1536 : 0 : free( parents );
1537 : 0 : free( es_array1 );
1538 : 0 : free( all_entities );
1539 : 0 : return FALSE;
1540 : : }
1541 : :
1542 : : /* get adjacent face of hexes */
1543 : 2 : adj_faces = NULL;
1544 : 2 : adj_faces_alloc = 0;
1545 : 2 : face_offsets = NULL;
1546 : 2 : face_offsets_alloc = 0;
1547 : :
1548 : : iMesh_getEntArrAdj( mesh, hexes, hexes_size, iBase_FACE, &adj_faces, &adj_faces_alloc, &adj_faces_size,
1549 [ + - ]: 2 : &face_offsets, &face_offsets_alloc, &face_offsets_size, &result );
1550 [ - + ]: 2 : if( iBase_SUCCESS != result )
1551 : : {
1552 [ # # ]: 0 : printf( "Problem to get adjacent entities in entitysets_test.\n" );
1553 : 0 : free( edges );
1554 : 0 : free( faces );
1555 : 0 : free( temp_entities1 );
1556 : 0 : free( temp_entities2 );
1557 : 0 : free( types );
1558 : 0 : free( regions );
1559 : 0 : free( parents );
1560 : 0 : free( es_array1 );
1561 : 0 : free( all_entities );
1562 : 0 : free( hexes );
1563 : 0 : return FALSE;
1564 : : }
1565 : :
1566 [ + - ]: 2 : iMesh_createEntSet( mesh, FALSE, &hex_set, &result );
1567 [ - + ]: 2 : if( iBase_SUCCESS != result )
1568 : : {
1569 [ # # ]: 0 : printf( "Problem creating entityset in entity_sets_test.\n" );
1570 : 0 : free( edges );
1571 : 0 : free( faces );
1572 : 0 : free( temp_entities1 );
1573 : 0 : free( temp_entities2 );
1574 : 0 : free( types );
1575 : 0 : free( regions );
1576 : 0 : free( parents );
1577 : 0 : free( es_array1 );
1578 : 0 : free( all_entities );
1579 : 0 : free( hexes );
1580 : 0 : free( adj_faces );
1581 : 0 : free( face_offsets );
1582 : 0 : return FALSE;
1583 : : }
1584 : :
1585 [ + - ]: 2 : iMesh_addEntArrToSet( mesh, hexes, hexes_size, hex_set, &result );
1586 [ - + ]: 2 : if( iBase_SUCCESS != result )
1587 : : {
1588 [ # # ]: 0 : printf( "Failed to add hexes in entity_sets_test.\n" );
1589 : 0 : free( edges );
1590 : 0 : free( faces );
1591 : 0 : free( temp_entities1 );
1592 : 0 : free( temp_entities2 );
1593 : 0 : free( types );
1594 : 0 : free( regions );
1595 : 0 : free( parents );
1596 : 0 : free( es_array1 );
1597 : 0 : free( all_entities );
1598 : 0 : free( hexes );
1599 : 0 : free( adj_faces );
1600 : 0 : free( face_offsets );
1601 : 0 : return FALSE;
1602 : : }
1603 : :
1604 : 2 : free( edges );
1605 : 2 : free( faces );
1606 : 2 : free( temp_entities1 );
1607 : 2 : free( temp_entities2 );
1608 : 2 : free( types );
1609 : 2 : free( regions );
1610 : 2 : free( parents );
1611 : 2 : free( es_array1 );
1612 : 2 : free( all_entities );
1613 : 2 : free( hexes );
1614 : 2 : free( adj_faces );
1615 : 2 : free( face_offsets );
1616 : :
1617 : 2 : return TRUE;
1618 : : }
1619 : :
1620 : 14 : int check_esets( iMesh_Instance mesh, const int num_sets )
1621 : : {
1622 : : int entity_sets_size;
1623 : :
1624 : : int result;
1625 [ + - ]: 14 : iMesh_getNumEntSets( mesh, root_set, 1, &entity_sets_size, &result );
1626 [ - + ]: 14 : if( iBase_SUCCESS != result )
1627 : : {
1628 [ # # ]: 0 : printf( "Problem to get all entity sets in mesh.\n" );
1629 : 0 : return FALSE;
1630 : : }
1631 [ - + ]: 14 : if( entity_sets_size != num_sets )
1632 : : {
1633 : : printf( "the number of entity sets in whole mesh should be %d"
1634 : : ", actual number is %d.\n",
1635 [ # # ]: 0 : num_sets, entity_sets_size );
1636 : 0 : return FALSE;
1637 : : }
1638 : :
1639 : 14 : return TRUE;
1640 : : }
1641 : :
1642 : : /*!
1643 : : @test
1644 : : TSTT entity sets Test
1645 : : @li Check entity sets
1646 : : */
1647 : 1 : int entity_sets_test( iMesh_Instance mesh )
1648 : : {
1649 : 1 : int iter_num = 0, result;
1650 : : /* check */
1651 : : int i;
1652 [ + + ]: 3 : for( i = 0; i < 2; i++ )
1653 : : {
1654 : 2 : iter_num++;
1655 : :
1656 : 2 : result = entity_sets_subtest( mesh, i, iter_num );
1657 [ - + ]: 2 : if( !result ) return result;
1658 : : }
1659 : :
1660 : 1 : return TRUE;
1661 : : }
1662 : :
1663 : : /*!
1664 : : @test
1665 : : Vertex Coordinates
1666 : : @li Get coordinates of vertices by 2 different methods then compare them
1667 : : */
1668 : 1 : int vertex_coordinates_test( iMesh_Instance mesh )
1669 : : {
1670 : 1 : iBase_EntityHandle* verts = NULL;
1671 : 1 : int verts_alloc = 0, verts_size;
1672 : 1 : double* vert_coords = NULL;
1673 : 1 : int vert_coords_alloc = 0, vert_coords_size;
1674 : :
1675 : : /* check storage order */
1676 : : int result;
1677 : : int this_order;
1678 [ + - ]: 1 : iMesh_getDfltStorage( mesh, &this_order, &result );
1679 [ - + ]: 1 : if( iBase_SUCCESS != result )
1680 : : {
1681 [ # # ]: 0 : printf( "failed to get preferred storage order in vertex_coordinates_test.\n" );
1682 : 0 : return FALSE;
1683 : : }
1684 : :
1685 : : /* now get the vertex coordinates from a vertex array */
1686 : : /* need to get the vertices in the model */
1687 : 1 : verts = NULL;
1688 : 1 : verts_alloc = 0;
1689 [ + - ]: 1 : iMesh_getEntities( mesh, root_set, iBase_VERTEX, iMesh_POINT, &verts, &verts_alloc, &verts_size, &result );
1690 [ - + ]: 1 : if( iBase_SUCCESS != result )
1691 : : {
1692 [ # # ]: 0 : printf( "failed to get entities in vertex_coordinates_test.\n" );
1693 : 0 : return FALSE;
1694 : : }
1695 : :
1696 : : /* get the coordinates in one array */
1697 : 1 : vert_coords = NULL;
1698 : 1 : vert_coords_alloc = 0;
1699 : :
1700 : : iMesh_getVtxArrCoords( mesh, verts, verts_size, iBase_INTERLEAVED, &vert_coords, &vert_coords_alloc,
1701 [ + - ]: 1 : &vert_coords_size, &result );
1702 [ - + ]: 1 : if( iBase_SUCCESS != result )
1703 : : {
1704 [ # # ]: 0 : printf( "failed to get vertex cooridinate of entities in vertex_coordinates_test.\n" );
1705 : 0 : free( verts );
1706 : 0 : return FALSE;
1707 : : }
1708 : :
1709 : 1 : free( verts );
1710 : 1 : free( vert_coords );
1711 : :
1712 : : /* if we get here, this test was successful */
1713 : 1 : return TRUE;
1714 : : }
1715 : :
1716 : : /*!
1717 : : @test
1718 : : TSTT Tag Info test
1719 : : @li Tests tagCreate, tagDelete, tagGetName, tagGetSize, tagGetHandle
1720 : : */
1721 : 1 : int tag_info_test( iMesh_Instance mesh )
1722 : : {
1723 : : char dum_name[120];
1724 : 1 : int dum_name_size = 120;
1725 : : int dum_size;
1726 : 1 : int error = FALSE;
1727 : : iBase_TagHandle dum_handle;
1728 : : /* Create a tag */
1729 : : int result;
1730 : 1 : iBase_TagHandle tag_handle = NULL;
1731 : 1 : const char* tag_name = "int_tag";
1732 : 1 : int tag_name_size = 8;
1733 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, 1, iBase_INTEGER, &tag_handle, &result, tag_name_size );
1734 [ - + ]: 1 : if( iBase_SUCCESS != result )
1735 : : {
1736 [ # # ]: 0 : printf( "Failed to create tag int_tag in vertex_tag_test." );
1737 : 0 : return FALSE;
1738 : : }
1739 : :
1740 : : /* check tag info functions */
1741 [ + - ]: 1 : iMesh_getTagName( mesh, tag_handle, dum_name, &result, dum_name_size );
1742 [ - + ]: 1 : if( iBase_SUCCESS != result )
1743 : : {
1744 [ # # ]: 0 : printf( "Couldn't get name of tag just created.\n" );
1745 : 0 : return FALSE;
1746 : : }
1747 [ - + ]: 1 : if( strcmp( dum_name, "int_tag" ) )
1748 : : {
1749 [ # # ]: 0 : printf( "Tag names didn't match.\n" );
1750 : 0 : return FALSE;
1751 : : }
1752 : :
1753 [ + - ]: 1 : iMesh_getTagSizeBytes( mesh, tag_handle, &dum_size, &result );
1754 [ - + ]: 1 : if( iBase_SUCCESS != result )
1755 : : {
1756 [ # # ]: 0 : printf( "Couldn't get size of tag just created.\n" );
1757 : 0 : return FALSE;
1758 : : }
1759 [ - + ]: 1 : if( dum_size != sizeof( int ) )
1760 : : {
1761 [ # # ]: 0 : printf( "Tag sizes didn't match.\n" );
1762 : 0 : return FALSE;
1763 : : }
1764 : :
1765 [ + - ]: 1 : iMesh_getTagHandle( mesh, tag_name, &dum_handle, &result, tag_name_size );
1766 [ - + ]: 1 : if( iBase_SUCCESS != result )
1767 : : {
1768 [ # # ]: 0 : printf( "Couldn't get handle of tag just created.\n" );
1769 : 0 : return FALSE;
1770 : : }
1771 [ - + ]: 1 : if( dum_handle != tag_handle )
1772 : : {
1773 [ # # ]: 0 : printf( "Tag handles didn't match.\n" );
1774 : 0 : return FALSE;
1775 : : }
1776 : :
1777 : : /* test non-forced version of tagDelete; forced version tested later, */
1778 : : /* when we have entities around */
1779 [ + - ]: 1 : iMesh_destroyTag( mesh, tag_handle, FALSE, &result );
1780 [ - + ]: 1 : if( iBase_SUCCESS != result )
1781 : : {
1782 [ # # ]: 0 : printf( "Couldn't delete tag just created.\n" );
1783 : 0 : return FALSE;
1784 : : }
1785 : :
1786 : : /* look for that tag, to make sure it got deleted */
1787 [ + - ]: 1 : iMesh_getTagHandle( mesh, tag_name, &tag_handle, &result, tag_name_size );
1788 [ + - ]: 1 : if( iBase_SUCCESS != result ) { error = TRUE; }
1789 [ - + ]: 1 : if( !error )
1790 : : {
1791 [ # # ]: 0 : printf( "tagGetHandle was able to find handle for deleted tag.\n" );
1792 : 0 : return FALSE;
1793 : : }
1794 : :
1795 : 1 : return TRUE;
1796 : : }
1797 : :
1798 : 1 : int vertex_int_tag_test( iMesh_Instance mesh, iBase_EntityHandle* verts, int /*verts_size*/, iBase_TagHandle* int_tag )
1799 : : {
1800 : : int result;
1801 : 1 : iBase_EntityHandle dum_vert = verts[0];
1802 : :
1803 : 1 : int dum_val = 11, dum_val2;
1804 : 1 : void* dum_val2_ptr = &dum_val2;
1805 : 1 : int dum_val2_alloc = sizeof( int ), dum_val2_size;
1806 : :
1807 : : /* create a tag */
1808 : 1 : const char* tag_name = "int_tag";
1809 : 1 : int tag_name_size = 8;
1810 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, 1, iBase_INTEGER, int_tag, &result, tag_name_size );
1811 [ - + ]: 1 : if( iBase_SUCCESS != result )
1812 : : {
1813 [ # # ]: 0 : printf( "Failed to create tag int_tag in vertex_int_tag_test.\n" );
1814 : 0 : return FALSE;
1815 : : }
1816 : :
1817 : : /* put a value in the first vertex and retrieve */
1818 [ + - ]: 1 : iMesh_setArrData( mesh, &dum_vert, 1, *int_tag, (const char*)( &dum_val ), sizeof( int ), &result );
1819 [ - + ]: 1 : if( iBase_SUCCESS != result )
1820 : : {
1821 [ # # ]: 0 : printf( "Failed to set int tag (val=11) in vertex_int_tag_test.\n" );
1822 : 0 : return FALSE;
1823 : : }
1824 : :
1825 [ + - ]: 1 : iMesh_getArrData( mesh, &dum_vert, 1, *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
1826 [ + - ][ - + ]: 1 : if( iBase_SUCCESS != result || dum_val2 != 11 )
1827 : : {
1828 [ # # ]: 0 : printf( "Failed to get int tag (val=11) in vertex_int_tag_test.\n" );
1829 : 0 : return FALSE;
1830 : : }
1831 : :
1832 [ - + ]: 1 : if( dum_val2 != 11 )
1833 : : {
1834 : :
1835 [ # # ]: 0 : printf( "Value of vertex tag (val=11) wrong.\n" );
1836 : 0 : return FALSE;
1837 : : }
1838 : :
1839 : : /* put a value in the last vertex and retrieve */
1840 : 1 : dum_val = 12;
1841 : :
1842 [ + - ]: 1 : iMesh_setArrData( mesh, &dum_vert, 1, *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
1843 [ - + ]: 1 : if( iBase_SUCCESS != result )
1844 : : {
1845 [ # # ]: 0 : printf( "Failed to set int tag (val=12) in vertex_int_tag_test.\n" );
1846 : 0 : return FALSE;
1847 : : }
1848 : :
1849 [ + - ]: 1 : iMesh_getArrData( mesh, &dum_vert, 1, *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
1850 [ - + ]: 1 : if( iBase_SUCCESS != result )
1851 : : {
1852 [ # # ]: 0 : printf( "Failed to get int tag (val=12) in vertex_int_tag_test.\n" );
1853 : 0 : return FALSE;
1854 : : }
1855 : :
1856 [ - + ]: 1 : if( dum_val2 != 12 )
1857 : : {
1858 : :
1859 [ # # ]: 0 : printf( "Value of vertex tag (val=12) wrong.\n" );
1860 : 0 : return FALSE;
1861 : : }
1862 : :
1863 : : /* ok, the int tag test worked */
1864 : 1 : return TRUE;
1865 : : }
1866 : :
1867 : 1 : int vertex_double_tag_test( iMesh_Instance mesh, iBase_EntityHandle* verts, int /*verts_size*/,
1868 : : iBase_TagHandle* double_tag )
1869 : : {
1870 : : int result;
1871 : :
1872 : 1 : iBase_EntityHandle dum_vert = verts[0];
1873 : 1 : double dum_val = 1.0e6, dum_val2;
1874 : 1 : void* dum_val2_ptr = &dum_val2;
1875 : 1 : int dum_val2_alloc = sizeof( double ), dum_val2_size;
1876 : :
1877 : : /* create a tag */
1878 : 1 : const char* tag_name = "double_tag";
1879 : 1 : int tag_name_size = 11;
1880 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, 1, iBase_DOUBLE, double_tag, &result, tag_name_size );
1881 [ - + ]: 1 : if( iBase_SUCCESS != result )
1882 : : {
1883 [ # # ]: 0 : printf( "Failed to create tag double_tag in vertex_double_tag_test.\n" );
1884 : 0 : return FALSE;
1885 : : }
1886 : :
1887 : : /* put a value in the first vertex and retrieve */
1888 [ + - ]: 1 : iMesh_setArrData( mesh, &dum_vert, 1, *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
1889 [ - + ]: 1 : if( iBase_SUCCESS != result )
1890 : : {
1891 [ # # ]: 0 : printf( "Failed to set double tag (val=1.0e6) in vertex_double_tag_test.\n" );
1892 : 0 : return FALSE;
1893 : : }
1894 : :
1895 [ + - ]: 1 : iMesh_getArrData( mesh, &dum_vert, 1, *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
1896 [ - + ]: 1 : if( iBase_SUCCESS != result )
1897 : : {
1898 [ # # ]: 0 : printf( "Failed to get double tag (val=1.0e6) in vertex_double_tag_test.\n" );
1899 : 0 : return FALSE;
1900 : : }
1901 : :
1902 [ - + ]: 1 : if( dum_val2 != 1.0e6 )
1903 : : {
1904 [ # # ]: 0 : printf( "Value of vertex tag (val=1.0e6) wrong.\n" );
1905 : 0 : return FALSE;
1906 : : }
1907 : :
1908 : : /* put a value in the last vertex and retrieve */
1909 : 1 : dum_val = 2.0e9;
1910 : :
1911 [ + - ]: 1 : iMesh_setArrData( mesh, &dum_vert, 1, *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
1912 [ - + ]: 1 : if( iBase_SUCCESS != result )
1913 : : {
1914 [ # # ]: 0 : printf( "Failed to set double tag (val=2.0e9) in vertex_double_tag_test.\n" );
1915 : 0 : return FALSE;
1916 : : }
1917 : :
1918 [ + - ]: 1 : iMesh_getArrData( mesh, &dum_vert, 1, *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
1919 [ - + ]: 1 : if( iBase_SUCCESS != result )
1920 : : {
1921 [ # # ]: 0 : printf( "Failed to get double tag (val=2.0e9) in vertex_double_tag_test.\n" );
1922 : 0 : return FALSE;
1923 : : }
1924 : :
1925 [ - + ]: 1 : if( dum_val2 != 2.0e9 )
1926 : : {
1927 [ # # ]: 0 : printf( "Value of vertex tag (val=2.0e9) wrong.\n" );
1928 : 0 : return FALSE;
1929 : : }
1930 : :
1931 : : /* ok, the double tag test worked */
1932 : 1 : return TRUE;
1933 : : }
1934 : :
1935 : : /* Add a struct Vertex Tag to the database */
1936 : : struct TagStruct
1937 : : {
1938 : : double test_double;
1939 : : int test_int1, test_int2;
1940 : : };
1941 : :
1942 : 1 : int vertex_struct_tag_test( iMesh_Instance mesh, iBase_EntityHandle* verts, int /*verts_size*/,
1943 : : iBase_TagHandle* struct_tag )
1944 : : {
1945 : : int result;
1946 : 1 : iBase_EntityHandle dum_vert = verts[0];
1947 : 1 : struct TagStruct dum_struct = { 3.0e12, 2, 3 }, dum_struct2;
1948 : 1 : void* dum_struct2_ptr = &dum_struct2;
1949 : 1 : int dum_struct_alloc = sizeof( struct TagStruct ), dum_struct_size;
1950 : :
1951 : : /* create a tag */
1952 : 1 : const char* tag_name = "struct_tag";
1953 : 1 : int tag_name_size = 11;
1954 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, sizeof( struct TagStruct ), iBase_BYTES, struct_tag, &result, tag_name_size );
1955 [ - + ]: 1 : if( iBase_SUCCESS != result )
1956 : : {
1957 [ # # ]: 0 : printf( "Failed to create tag struct_tag in vertex_struct_tag_test.\n" );
1958 : 0 : return FALSE;
1959 : : }
1960 : :
1961 : : /* put a value in the first vertex and retrieve */
1962 : :
1963 : : /* careful setting the value, since tags are opaque */
1964 [ + - ]: 1 : iMesh_setArrData( mesh, &dum_vert, 1, *struct_tag, (const char*)&dum_struct, sizeof( struct TagStruct ), &result );
1965 [ - + ]: 1 : if( iBase_SUCCESS != result )
1966 : : {
1967 [ # # ]: 0 : printf( "Failed to set struct tag in vertex_struct_tag_test.\n" );
1968 : 0 : return FALSE;
1969 : : }
1970 : :
1971 [ + - ]: 1 : iMesh_getArrData( mesh, &dum_vert, 1, *struct_tag, &dum_struct2_ptr, &dum_struct_alloc, &dum_struct_size, &result );
1972 [ - + ]: 1 : if( iBase_SUCCESS != result )
1973 : : {
1974 [ # # ]: 0 : printf( "Failed to get struct tag in vertex_struct_tag_test.\n" );
1975 : 0 : return FALSE;
1976 : : }
1977 : :
1978 [ - + ]: 1 : if( dum_struct_size != sizeof( struct TagStruct ) )
1979 : : {
1980 [ # # ]: 0 : printf( "Size of vertex struct tag wrong.\n" );
1981 : 0 : return FALSE;
1982 : : }
1983 [ + - ][ + - ]: 1 : if( dum_struct2.test_int1 != dum_struct.test_int1 || dum_struct2.test_int2 != dum_struct.test_int2 ||
[ - + ]
1984 : 1 : dum_struct2.test_double != dum_struct.test_double )
1985 : : {
1986 [ # # ]: 0 : printf( "Value of vertex struct tag wrong.\n" );
1987 : 0 : return FALSE;
1988 : : }
1989 : :
1990 : : /* ok, the int tag test worked */
1991 : 1 : return TRUE;
1992 : : }
1993 : :
1994 : 1 : int vertex_tag_delete_test( iMesh_Instance mesh, iBase_EntityHandle* verts, int /*verts_size*/ )
1995 : : {
1996 : : int result;
1997 : 1 : int delete_err = FALSE;
1998 : :
1999 : : /* test forced, unforced deletion of tags from entities */
2000 : :
2001 : : /* test getAlliBase_TagHandles for first entity */
2002 : 1 : iBase_TagHandle* all_tags = NULL;
2003 : 1 : iBase_EntityHandle dum_entity = verts[0];
2004 : 1 : int all_tags_alloc = 0, all_tags_size;
2005 [ + - ]: 1 : iMesh_getAllTags( mesh, verts[0], &all_tags, &all_tags_alloc, &all_tags_size, &result );
2006 [ - + ]: 1 : if( iBase_SUCCESS != result )
2007 : : {
2008 [ # # ]: 0 : printf( "Couldn't get all tag handles from vertex.\n" );
2009 : 0 : return FALSE;
2010 : : }
2011 : :
2012 [ + - ]: 1 : iMesh_rmvArrTag( mesh, &dum_entity, 1, all_tags[0], &result );
2013 [ - + ]: 1 : if( iBase_SUCCESS != result )
2014 : : {
2015 [ # # ]: 0 : printf( "Couldn't remove tag from vertex.\n" );
2016 : 0 : free( all_tags );
2017 : 0 : return FALSE;
2018 : : }
2019 : :
2020 [ + - ]: 1 : iMesh_destroyTag( mesh, all_tags[1], FALSE, &result );
2021 [ + - ]: 1 : if( iBase_SUCCESS != result ) { delete_err = TRUE; }
2022 [ - + ]: 1 : if( !delete_err )
2023 : : {
2024 [ # # ]: 0 : printf( "Error when unforced-deleting tag in use on a vertex.\n" );
2025 : 0 : free( all_tags );
2026 : 0 : return FALSE;
2027 : : }
2028 : :
2029 [ + - ]: 1 : iMesh_destroyTag( mesh, all_tags[1], TRUE, &result );
2030 [ - + ]: 1 : if( iBase_SUCCESS != result )
2031 : : {
2032 [ # # ]: 0 : printf( "Couldn't force-delete a tag in use on a vertex.\n" );
2033 : 0 : free( all_tags );
2034 : 0 : return FALSE;
2035 : : }
2036 : :
2037 : 1 : free( all_tags );
2038 : :
2039 : : /* ok, we're done */
2040 : 1 : return TRUE;
2041 : : }
2042 : :
2043 : 1 : int vertex_tag_test( iMesh_Instance mesh )
2044 : : {
2045 : : int result;
2046 : :
2047 : : iBase_TagHandle int_tag, double_tag, struct_tag;
2048 : : int int_err, double_err, struct_err, tag_delete_err;
2049 : :
2050 [ + - ]: 1 : int info_err = tag_info_test( mesh );
2051 : :
2052 : : /* get all the vertices */
2053 : 1 : iBase_EntityHandle* verts = NULL;
2054 : 1 : int verts_alloc = 0, verts_size;
2055 [ + - ]: 1 : iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_POINT, &verts, &verts_alloc, &verts_size, &result );
2056 [ - + ]: 1 : if( iBase_SUCCESS != result )
2057 : : {
2058 [ # # ]: 0 : printf( "entitysetGetEntities failed in vertex_tag_test.\n" );
2059 : 0 : return FALSE;
2060 : : }
2061 : :
2062 : : /* vertex int tag */
2063 [ + - ]: 1 : int_err = vertex_int_tag_test( mesh, verts, verts_size, &int_tag );
2064 : :
2065 : : /* vertex double tag */
2066 [ + - ]: 1 : double_err = vertex_double_tag_test( mesh, verts, verts_size, &double_tag );
2067 : :
2068 : : /* vertex struct tag */
2069 [ + - ]: 1 : struct_err = vertex_struct_tag_test( mesh, verts, verts_size, &struct_tag );
2070 : :
2071 [ + - ]: 1 : tag_delete_err = vertex_tag_delete_test( mesh, verts, verts_size );
2072 : :
2073 : 1 : free( verts );
2074 : :
2075 [ + - ][ + - ]: 1 : return ( info_err && int_err && double_err && struct_err && tag_delete_err );
[ + - ][ + - ]
[ + - ]
2076 : : }
2077 : :
2078 : 1 : int entityset_int_tag_test( iMesh_Instance mesh, iBase_EntitySetHandle* sets, int sets_size, iBase_TagHandle* int_tag )
2079 : : {
2080 : : int result;
2081 : 1 : int dum_val = 11, dum_val2;
2082 : 1 : void* dum_val2_ptr = &dum_val2;
2083 : 1 : int dum_val2_alloc = sizeof( int ), dum_val2_size;
2084 : :
2085 : : /* create a tag */
2086 : 1 : const char* tag_name = "set_int_tag";
2087 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, 1, iBase_INTEGER, int_tag, &result, 12 );
2088 [ - + ]: 1 : if( iBase_SUCCESS != result )
2089 : : {
2090 [ # # ]: 0 : printf( "Failed to create tag int_tag in entityset_int_tag_test.\n" );
2091 : 0 : return FALSE;
2092 : : }
2093 : :
2094 : : /* put a value in the first set and retrieve */
2095 : :
2096 [ + - ]: 1 : iMesh_setEntSetData( mesh, sets[0], *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
2097 [ - + ]: 1 : if( iBase_SUCCESS != result )
2098 : : {
2099 [ # # ]: 0 : printf( "Failed to set int tag (val=11) in entityset_int_tag_test.\n" );
2100 : 0 : return FALSE;
2101 : : }
2102 : :
2103 : 1 : dum_val2 = 0;
2104 [ + - ]: 1 : iMesh_getEntSetData( mesh, sets[0], *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
2105 [ - + ]: 1 : if( iBase_SUCCESS != result )
2106 : : {
2107 [ # # ]: 0 : printf( "Failed to get int tag (val=11) in entityset_int_tag_test." );
2108 : 0 : return FALSE;
2109 : : }
2110 : :
2111 [ - + ]: 1 : if( dum_val2 != 11 )
2112 : : {
2113 [ # # ]: 0 : printf( "Value of entityset tag (val=11) wrong.\n" );
2114 : 0 : return FALSE;
2115 : : }
2116 : :
2117 : : /* put a value in the last faces and retrieve */
2118 : 1 : dum_val = 12;
2119 [ + - ]: 1 : iMesh_setEntSetData( mesh, sets[sets_size - 1], *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
2120 [ - + ]: 1 : if( iBase_SUCCESS != result )
2121 : : {
2122 [ # # ]: 0 : printf( "Failed to set int tag (val=12) in entityset_int_tag_test." );
2123 : 0 : return FALSE;
2124 : : }
2125 : :
2126 [ + - ]: 1 : iMesh_getEntSetData( mesh, sets[sets_size - 1], *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
2127 [ - + ]: 1 : if( iBase_SUCCESS != result )
2128 : : {
2129 [ # # ]: 0 : printf( "Failed to get int tag (val=12) in entityset_int_tag_test." );
2130 : 0 : return FALSE;
2131 : : }
2132 : :
2133 [ - + ]: 1 : if( dum_val2 != 12 )
2134 : : {
2135 [ # # ]: 0 : printf( "Value of entityset tag (val=12) wrong.\n" );
2136 : 0 : return FALSE;
2137 : : }
2138 : :
2139 : : /* ok, the int tag test worked */
2140 : 1 : return TRUE;
2141 : : }
2142 : :
2143 : 1 : int entityset_double_tag_test( iMesh_Instance mesh, iBase_EntitySetHandle* sets, int sets_size,
2144 : : iBase_TagHandle* double_tag )
2145 : : {
2146 : : int result;
2147 : 1 : double dum_val = 1.0e6, dum_val2;
2148 : 1 : void* dum_val2_ptr = &dum_val2;
2149 : 1 : int dum_val2_alloc = sizeof( double ), dum_val2_size;
2150 : :
2151 : : /* create a tag */
2152 : 1 : const char* tag_name = "set_double_tag";
2153 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, 1, iBase_DOUBLE, double_tag, &result, 15 );
2154 [ - + ]: 1 : if( iBase_SUCCESS != result )
2155 : : {
2156 [ # # ]: 0 : printf( "Failed to create tag double_tag in entityset_double_tag_test.\n" );
2157 : 0 : return FALSE;
2158 : : }
2159 : :
2160 : : /* put a value in the first set and retrieve */
2161 : :
2162 [ + - ]: 1 : iMesh_setEntSetData( mesh, sets[0], *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
2163 [ - + ]: 1 : if( iBase_SUCCESS != result )
2164 : : {
2165 [ # # ]: 0 : printf( "Failed to set double tag (val=11) in entityset_double_tag_test.\n" );
2166 : 0 : return FALSE;
2167 : : }
2168 : :
2169 : 1 : dum_val2 = 0;
2170 [ + - ]: 1 : iMesh_getEntSetData( mesh, sets[0], *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
2171 [ - + ]: 1 : if( iBase_SUCCESS != result )
2172 : : {
2173 [ # # ]: 0 : printf( "Failed to get double tag (val=1.0e6) in entityset_double_tag_test." );
2174 : 0 : return FALSE;
2175 : : }
2176 : :
2177 [ - + ]: 1 : if( dum_val2 != 1.0e6 )
2178 : : {
2179 [ # # ]: 0 : printf( "Value of entityset tag (val=11) wrong.\n" );
2180 : 0 : return FALSE;
2181 : : }
2182 : :
2183 : : /* put a value in the last faces and retrieve */
2184 : 1 : dum_val = 2.0e9;
2185 [ + - ]: 1 : iMesh_setEntSetData( mesh, sets[sets_size - 1], *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
2186 [ - + ]: 1 : if( iBase_SUCCESS != result )
2187 : : {
2188 [ # # ]: 0 : printf( "Failed to set double tag (val=2.0e9) in entityset_double_tag_test." );
2189 : 0 : return FALSE;
2190 : : }
2191 : :
2192 : 1 : iMesh_getEntSetData( mesh, sets[sets_size - 1], *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size,
2193 [ + - ]: 1 : &result );
2194 [ - + ]: 1 : if( iBase_SUCCESS != result )
2195 : : {
2196 [ # # ]: 0 : printf( "Failed to get double tag (val=2.0e9) in entityset_double_tag_test." );
2197 : 0 : return FALSE;
2198 : : }
2199 : :
2200 [ - + ]: 1 : if( dum_val2 != 2.0e9 )
2201 : : {
2202 [ # # ]: 0 : printf( "Value of entityset tag (val=2.0e9) wrong.\n" );
2203 : 0 : return FALSE;
2204 : : }
2205 : :
2206 : : /* ok, the double tag test worked */
2207 : 1 : return TRUE;
2208 : : }
2209 : :
2210 : 1 : int entityset_struct_tag_test( iMesh_Instance mesh, iBase_EntitySetHandle* /*sets*/, int /*sets_size*/,
2211 : : iBase_TagHandle* struct_tag )
2212 : : {
2213 : : int result;
2214 : 1 : struct TagStruct dum_struct = { 3.0e12, 2, 3 }, dum_struct2;
2215 : 1 : void* dum_struct2_ptr = &dum_struct2;
2216 : 1 : int dum_struct_alloc = sizeof( struct TagStruct ), dum_struct_size;
2217 : :
2218 : : /* create a tag */
2219 : 1 : const char* tag_name = "set_struct_tag";
2220 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, sizeof( struct TagStruct ), iBase_BYTES, struct_tag, &result, 11 );
2221 [ - + ]: 1 : if( iBase_SUCCESS != result )
2222 : : {
2223 [ # # ]: 0 : printf( "Failed to create tag struct_tag in entityset_struct_tag_test.\n" );
2224 : 0 : return FALSE;
2225 : : }
2226 : :
2227 : : /* put a value in the first vertex and retrieve */
2228 : :
2229 : : /* careful setting the value, since tags are opaque */
2230 [ + - ]: 1 : iMesh_setEntSetData( mesh, root_set, *struct_tag, (const char*)&dum_struct, sizeof( struct TagStruct ), &result );
2231 [ - + ]: 1 : if( iBase_SUCCESS != result )
2232 : : {
2233 [ # # ]: 0 : printf( "Failed to set struct tag in entityset_struct_tag_test.\n" );
2234 : 0 : return FALSE;
2235 : : }
2236 : :
2237 [ + - ]: 1 : iMesh_getEntSetData( mesh, root_set, *struct_tag, &dum_struct2_ptr, &dum_struct_alloc, &dum_struct_size, &result );
2238 [ - + ]: 1 : if( iBase_SUCCESS != result )
2239 : : {
2240 [ # # ]: 0 : printf( "Failed to get struct tag in entityset_struct_tag_test.\n" );
2241 : 0 : return FALSE;
2242 : : }
2243 : :
2244 [ - + ]: 1 : if( dum_struct_size != sizeof( struct TagStruct ) )
2245 : : {
2246 [ # # ]: 0 : printf( "Size of entityset struct tag wrong.\n" );
2247 : 0 : return FALSE;
2248 : : }
2249 [ + - ][ + - ]: 1 : if( dum_struct2.test_int1 != dum_struct.test_int1 || dum_struct2.test_int2 != dum_struct.test_int2 ||
[ - + ]
2250 : 1 : dum_struct2.test_double != dum_struct.test_double )
2251 : : {
2252 [ # # ]: 0 : printf( "Value of entityset struct tag wrong.\n" );
2253 : 0 : return FALSE;
2254 : : }
2255 : :
2256 : : /* ok, the int tag test worked */
2257 : 1 : return TRUE;
2258 : : }
2259 : :
2260 : 1 : int entityset_tag_delete_test( iMesh_Instance mesh, iBase_EntitySetHandle* sets, int sets_size )
2261 : : {
2262 : : /* test forced, unforced deletion of tags from entities */
2263 : : int result;
2264 : 1 : int delete_err = FALSE;
2265 : :
2266 : : /* test getAlliBase_TagHandles for first entity */
2267 : 1 : iBase_TagHandle* all_tags = NULL;
2268 [ - + ]: 1 : if( sets_size < 1 )
2269 : : {
2270 [ # # ]: 0 : printf( "no sets.\n" );
2271 : 0 : return FALSE;
2272 : : }
2273 : 1 : iBase_EntitySetHandle dum_entity = sets[0];
2274 : 1 : int all_tags_alloc = 0, all_tags_size;
2275 [ + - ]: 1 : iMesh_getAllEntSetTags( mesh, sets[0], &all_tags, &all_tags_alloc, &all_tags_size, &result );
2276 [ - + ]: 1 : if( iBase_SUCCESS != result )
2277 : : {
2278 [ # # ]: 0 : printf( "Couldn't get all tag handles from entityset.\n" );
2279 : 0 : free( all_tags );
2280 : 0 : return FALSE;
2281 : : }
2282 : :
2283 [ + - ]: 1 : iMesh_rmvEntSetTag( mesh, dum_entity, all_tags[0], &result );
2284 [ - + ]: 1 : if( iBase_SUCCESS != result )
2285 : : {
2286 [ # # ]: 0 : printf( "Couldn't remove tag from entityset.\n" );
2287 : 0 : free( all_tags );
2288 : 0 : return FALSE;
2289 : : }
2290 : :
2291 [ + - ]: 1 : iMesh_destroyTag( mesh, all_tags[1], FALSE, &result );
2292 [ + - ]: 1 : if( iBase_SUCCESS != result ) { delete_err = TRUE; }
2293 [ - + ]: 1 : if( !delete_err )
2294 : : {
2295 [ # # ]: 0 : printf( "Error when unforced-deleting tag in use on a entityset.\n" );
2296 : 0 : free( all_tags );
2297 : 0 : return FALSE;
2298 : : }
2299 : :
2300 [ + - ]: 1 : iMesh_destroyTag( mesh, all_tags[1], TRUE, &result );
2301 [ - + ]: 1 : if( iBase_SUCCESS != result )
2302 : : {
2303 [ # # ]: 0 : printf( "Couldn't force-delete a tag in use on a entityset.\n" );
2304 : 0 : free( all_tags );
2305 : 0 : return FALSE;
2306 : : }
2307 : :
2308 : 1 : free( all_tags );
2309 : :
2310 : : /* ok, we're done */
2311 : 1 : return TRUE;
2312 : : }
2313 : :
2314 : : /*!
2315 : : @test
2316 : : TSTT entityset tag Test
2317 : : @li Check entityset tags
2318 : : */
2319 : 1 : int entityset_tag_test( iMesh_Instance mesh )
2320 : : {
2321 : : int result;
2322 : : iBase_TagHandle int_tag, double_tag, struct_tag;
2323 : : int int_success, double_success, struct_success, tag_delete_success;
2324 : :
2325 : : /* get the sets */
2326 : 1 : iBase_EntitySetHandle* esets = NULL;
2327 : 1 : int esets_alloc = 0, esets_size;
2328 [ + - ]: 1 : iMesh_getEntSets( mesh, root_set, 1, &esets, &esets_alloc, &esets_size, &result );
2329 [ - + ]: 1 : if( iBase_SUCCESS != result )
2330 : : {
2331 [ # # ]: 0 : printf( "entitysetGetEntities failed in entityset_tag_test.\n" );
2332 : 0 : free( esets );
2333 : 0 : return FALSE;
2334 : : }
2335 : :
2336 : : /* entityset int tag */
2337 [ + - ]: 1 : int_success = entityset_int_tag_test( mesh, esets, esets_size, &int_tag );
2338 : :
2339 : : /* entityeset double tag */
2340 [ + - ]: 1 : double_success = entityset_double_tag_test( mesh, esets, esets_size, &double_tag );
2341 : :
2342 : : /* entityset struct tag */
2343 [ + - ]: 1 : struct_success = entityset_struct_tag_test( mesh, esets, esets_size, &struct_tag );
2344 : :
2345 [ + - ]: 1 : tag_delete_success = entityset_tag_delete_test( mesh, esets, esets_size );
2346 : :
2347 : 1 : free( esets );
2348 : :
2349 [ + - ][ + - ]: 1 : return ( int_success && double_success && struct_success && tag_delete_success );
[ + - ][ + - ]
2350 : : }
2351 : :
2352 : 1 : int mesh_int_tag_test( iMesh_Instance mesh, iBase_TagHandle* int_tag )
2353 : : {
2354 : : int result;
2355 : 1 : int dum_val = 11, dum_val2;
2356 : 1 : void* dum_val2_ptr = &dum_val2;
2357 : 1 : int dum_val2_alloc = sizeof( int ), dum_val2_size;
2358 : :
2359 : : /* create a tag */
2360 : 1 : const char* tag_name = "mesh_int_tag";
2361 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, 1, iBase_INTEGER, int_tag, &result, 12 );
2362 [ - + ]: 1 : if( iBase_SUCCESS != result )
2363 : : {
2364 [ # # ]: 0 : printf( "Failed to create tag int_tag in mesh_int_tag_test.\n" );
2365 : 0 : return FALSE;
2366 : : }
2367 : :
2368 : : /* put a value in the first set and retrieve */
2369 : :
2370 [ + - ]: 1 : iMesh_setEntSetData( mesh, root_set, *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
2371 [ - + ]: 1 : if( iBase_SUCCESS != result )
2372 : : {
2373 [ # # ]: 0 : printf( "Failed to set int tag (val=11) in mesh_int_tag_test.\n" );
2374 : 0 : return FALSE;
2375 : : }
2376 : :
2377 : 1 : dum_val2 = 0;
2378 [ + - ]: 1 : iMesh_getEntSetData( mesh, root_set, *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
2379 [ - + ]: 1 : if( iBase_SUCCESS != result )
2380 : : {
2381 [ # # ]: 0 : printf( "Failed to get int tag (val=11) in mesh_int_tag_test." );
2382 : 0 : return FALSE;
2383 : : }
2384 : :
2385 [ - + ]: 1 : if( dum_val2 != 11 )
2386 : : {
2387 [ # # ]: 0 : printf( "Value of entityset tag (val=11) wrong.\n" );
2388 : 0 : return FALSE;
2389 : : }
2390 : :
2391 : : /* put a value in the last faces and retrieve */
2392 : 1 : dum_val = 12;
2393 [ + - ]: 1 : iMesh_setEntSetData( mesh, root_set, *int_tag, (char*)( &dum_val ), sizeof( int ), &result );
2394 [ - + ]: 1 : if( iBase_SUCCESS != result )
2395 : : {
2396 [ # # ]: 0 : printf( "Failed to set int tag (val=12) in mesh_int_tag_test." );
2397 : 0 : return FALSE;
2398 : : }
2399 : :
2400 [ + - ]: 1 : iMesh_getEntSetData( mesh, root_set, *int_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
2401 [ - + ]: 1 : if( iBase_SUCCESS != result )
2402 : : {
2403 [ # # ]: 0 : printf( "Failed to get int tag (val=12) in mesh_int_tag_test." );
2404 : 0 : return FALSE;
2405 : : }
2406 : :
2407 [ - + ]: 1 : if( dum_val2 != 12 )
2408 : : {
2409 [ # # ]: 0 : printf( "Value of entityset tag (val=12) wrong.\n" );
2410 : 0 : return FALSE;
2411 : : }
2412 : :
2413 : : /* ok, the int tag test worked */
2414 : 1 : return TRUE;
2415 : : }
2416 : :
2417 : 1 : int mesh_double_tag_test( iMesh_Instance mesh, iBase_TagHandle* double_tag )
2418 : : {
2419 : : int result;
2420 : 1 : double dum_val = 1.0e6, dum_val2;
2421 : 1 : void* dum_val2_ptr = &dum_val2;
2422 : 1 : int dum_val2_alloc = sizeof( double ), dum_val2_size;
2423 : :
2424 : : /* create a tag */
2425 : 1 : const char* tag_name = "mesh_double_tag";
2426 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, 1, iBase_DOUBLE, double_tag, &result, 15 );
2427 [ - + ]: 1 : if( iBase_SUCCESS != result )
2428 : : {
2429 [ # # ]: 0 : printf( "Failed to create tag double_tag in mesh_double_tag_test.\n" );
2430 : 0 : return FALSE;
2431 : : }
2432 : :
2433 : : /* put a value in the first set and retrieve */
2434 : :
2435 [ + - ]: 1 : iMesh_setEntSetData( mesh, root_set, *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
2436 [ - + ]: 1 : if( iBase_SUCCESS != result )
2437 : : {
2438 [ # # ]: 0 : printf( "Failed to set double tag (val=11) in mesh_double_tag_test.\n" );
2439 : 0 : return FALSE;
2440 : : }
2441 : :
2442 : 1 : dum_val2 = 0;
2443 [ + - ]: 1 : iMesh_getEntSetData( mesh, root_set, *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
2444 [ - + ]: 1 : if( iBase_SUCCESS != result )
2445 : : {
2446 [ # # ]: 0 : printf( "Failed to get double tag (val=1.0e6) in mesh_double_tag_test." );
2447 : 0 : return FALSE;
2448 : : }
2449 : :
2450 [ - + ]: 1 : if( dum_val2 != 1.0e6 )
2451 : : {
2452 [ # # ]: 0 : printf( "Value of entityset tag (val=11) wrong.\n" );
2453 : 0 : return FALSE;
2454 : : }
2455 : :
2456 : : /* put a value in the last faces and retrieve */
2457 : 1 : dum_val = 2.0e9;
2458 [ + - ]: 1 : iMesh_setEntSetData( mesh, root_set, *double_tag, (char*)( &dum_val ), sizeof( double ), &result );
2459 [ - + ]: 1 : if( iBase_SUCCESS != result )
2460 : : {
2461 [ # # ]: 0 : printf( "Failed to set double tag (val=2.0e9) in mesh_double_tag_test." );
2462 : 0 : return FALSE;
2463 : : }
2464 : :
2465 [ + - ]: 1 : iMesh_getEntSetData( mesh, root_set, *double_tag, &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result );
2466 [ - + ]: 1 : if( iBase_SUCCESS != result )
2467 : : {
2468 [ # # ]: 0 : printf( "Failed to get double tag (val=2.0e9) in mesh_double_tag_test." );
2469 : 0 : return FALSE;
2470 : : }
2471 : :
2472 [ - + ]: 1 : if( dum_val2 != 2.0e9 )
2473 : : {
2474 [ # # ]: 0 : printf( "Value of entityset tag (val=2.0e9) wrong.\n" );
2475 : 0 : return FALSE;
2476 : : }
2477 : :
2478 : : /* ok, the double tag test worked */
2479 : 1 : return TRUE;
2480 : : }
2481 : :
2482 : 1 : int mesh_struct_tag_test( iMesh_Instance mesh, iBase_TagHandle* struct_tag )
2483 : : {
2484 : : int result;
2485 : 1 : struct TagStruct dum_struct = { 3.0e12, 2, 3 }, dum_struct2;
2486 : 1 : void* dum_struct2_ptr = &dum_struct2;
2487 : 1 : int dum_struct_alloc = sizeof( struct TagStruct ), dum_struct_size;
2488 : :
2489 : : /* create a tag */
2490 : 1 : const char* tag_name = "mesh_struct_tag";
2491 [ + - ]: 1 : iMesh_createTag( mesh, tag_name, sizeof( struct TagStruct ), iBase_BYTES, struct_tag, &result, 11 );
2492 [ - + ]: 1 : if( iBase_SUCCESS != result )
2493 : : {
2494 [ # # ]: 0 : printf( "Failed to create tag struct_tag in vertex_struct_tag_test.\n" );
2495 : 0 : return FALSE;
2496 : : }
2497 : :
2498 : : /* put a value in the first vertex and retrieve */
2499 : :
2500 : : /* careful setting the value, since tags are opaque */
2501 [ + - ]: 1 : iMesh_setEntSetData( mesh, root_set, *struct_tag, (const char*)&dum_struct, sizeof( struct TagStruct ), &result );
2502 [ - + ]: 1 : if( iBase_SUCCESS != result )
2503 : : {
2504 [ # # ]: 0 : printf( "Failed to set struct tag in mesh_struct_tag_test.\n" );
2505 : 0 : return FALSE;
2506 : : }
2507 : :
2508 [ + - ]: 1 : iMesh_getEntSetData( mesh, root_set, *struct_tag, &dum_struct2_ptr, &dum_struct_alloc, &dum_struct_size, &result );
2509 [ - + ]: 1 : if( iBase_SUCCESS != result )
2510 : : {
2511 [ # # ]: 0 : printf( "Failed to get struct tag in mesh_struct_tag_test.\n" );
2512 : 0 : return FALSE;
2513 : : }
2514 : :
2515 [ - + ]: 1 : if( dum_struct_size != sizeof( struct TagStruct ) )
2516 : : {
2517 [ # # ]: 0 : printf( "Size of entityset struct tag wrong.\n" );
2518 : 0 : return FALSE;
2519 : : }
2520 [ + - ][ + - ]: 1 : if( dum_struct2.test_int1 != dum_struct.test_int1 || dum_struct2.test_int2 != dum_struct.test_int2 ||
[ - + ]
2521 : 1 : dum_struct2.test_double != dum_struct.test_double )
2522 : : {
2523 [ # # ]: 0 : printf( "Value of entityset struct tag wrong.\n" );
2524 : 0 : return FALSE;
2525 : : }
2526 : :
2527 : : /* ok, the int tag test worked */
2528 : 1 : return TRUE;
2529 : : }
2530 : :
2531 : 1 : int mesh_tag_delete_test( iMesh_Instance mesh )
2532 : : {
2533 : : /* test forced, unforced deletion of tags from entities */
2534 : : int result;
2535 : 1 : int delete_err = FALSE;
2536 : :
2537 : : /* test getAlliBase_TagHandles for first entity */
2538 : 1 : iBase_TagHandle* all_tags = NULL;
2539 : 1 : int all_tags_alloc = 0, all_tags_size;
2540 [ + - ]: 1 : iMesh_getAllEntSetTags( mesh, root_set, &all_tags, &all_tags_alloc, &all_tags_size, &result );
2541 [ - + ]: 1 : if( iBase_SUCCESS != result )
2542 : : {
2543 [ # # ]: 0 : printf( "Couldn't get all tag handles from entityset.\n" );
2544 : 0 : return FALSE;
2545 : : }
2546 : :
2547 [ + - ]: 1 : iMesh_rmvEntSetTag( mesh, root_set, all_tags[0], &result );
2548 [ - + ]: 1 : if( iBase_SUCCESS != result )
2549 : : {
2550 [ # # ]: 0 : printf( "Couldn't remove tag from entityset.\n" );
2551 : 0 : free( all_tags );
2552 : 0 : return FALSE;
2553 : : }
2554 : :
2555 [ + - ]: 1 : iMesh_destroyTag( mesh, all_tags[1], FALSE, &result );
2556 [ + - ]: 1 : if( iBase_SUCCESS != result ) { delete_err = TRUE; }
2557 [ - + ]: 1 : if( !delete_err )
2558 : : {
2559 [ # # ]: 0 : printf( "Error when unforced-deleting tag in use on a entityset.\n" );
2560 : 0 : free( all_tags );
2561 : 0 : return FALSE;
2562 : : }
2563 : :
2564 [ + - ]: 1 : iMesh_destroyTag( mesh, all_tags[1], TRUE, &result );
2565 [ - + ]: 1 : if( iBase_SUCCESS != result )
2566 : : {
2567 [ # # ]: 0 : printf( "Couldn't force-delete a tag in use on a entityset.\n" );
2568 : 0 : free( all_tags );
2569 : 0 : return FALSE;
2570 : : }
2571 : :
2572 : 1 : free( all_tags );
2573 : :
2574 : : /* ok, we're done */
2575 : 1 : return TRUE;
2576 : : }
2577 : :
2578 : : /*!
2579 : : @test
2580 : : TSTT entityset tag Test
2581 : : @li Check entityset tags
2582 : : */
2583 : 1 : int mesh_tag_test( iMesh_Instance mesh )
2584 : : {
2585 : : iBase_TagHandle int_tag, double_tag, struct_tag;
2586 : :
2587 : : /* entityset int tag */
2588 [ + - ]: 1 : int int_success = mesh_int_tag_test( mesh, &int_tag );
2589 : :
2590 : : /* entityeset double tag */
2591 [ + - ]: 1 : int double_success = mesh_double_tag_test( mesh, &double_tag );
2592 : :
2593 : : /* entityset struct tag */
2594 [ + - ]: 1 : int struct_success = mesh_struct_tag_test( mesh, &struct_tag );
2595 : :
2596 [ + - ]: 1 : int tag_delete_success = mesh_tag_delete_test( mesh );
2597 : :
2598 [ + - ][ + - ]: 1 : return ( int_success && double_success && struct_success && tag_delete_success );
[ + - ][ + - ]
2599 : : }
2600 : :
2601 : 1 : int set_remove_contained_regression( iMesh_Instance mesh )
2602 : : {
2603 : : int err, contained;
2604 : : iBase_EntitySetHandle set, sub;
2605 : :
2606 [ + - ]: 1 : iMesh_createEntSet( mesh, 0, &set, &err );
2607 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2608 [ + - ]: 1 : iMesh_createEntSet( mesh, 1, &sub, &err );
2609 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2610 : :
2611 [ + - ]: 1 : iMesh_addEntSet( mesh, sub, set, &err );
2612 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2613 : :
2614 [ + - ]: 1 : iMesh_isEntSetContained( mesh, set, sub, &contained, &err );
2615 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2616 [ - + ]: 1 : if( !contained )
2617 : : {
2618 [ # # ]: 0 : fprintf( stderr, "isEntSetContained returned false for contained set\n" );
2619 : 0 : return 0;
2620 : : }
2621 : :
2622 [ + - ]: 1 : iMesh_rmvEntSet( mesh, sub, set, &err );
2623 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2624 : :
2625 [ + - ]: 1 : iMesh_isEntSetContained( mesh, set, sub, &contained, &err );
2626 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2627 [ - + ]: 1 : if( contained )
2628 : : {
2629 [ # # ]: 0 : fprintf( stderr, "isEntSetContained returned true for removed set\n" );
2630 : 0 : return 0;
2631 : : }
2632 : :
2633 : 1 : return 1;
2634 : : }
2635 : :
2636 : 1 : int all_adjacency_regression( iMesh_Instance mesh )
2637 : : {
2638 : : int err;
2639 : :
2640 : 1 : double coords[] = { 0, 0, 0, 1, 1, 1 };
2641 : :
2642 : 1 : iBase_EntityHandle* verts = NULL;
2643 : 1 : int verts_alloc = 0, verts_size;
2644 : :
2645 : : iBase_EntityHandle line;
2646 : : int status;
2647 : :
2648 : 1 : iBase_EntityHandle* adj = NULL;
2649 : 1 : int adj_alloc = 0, adj_size;
2650 : :
2651 [ + - ]: 1 : iMesh_newMesh( "", &mesh, &err, 0 );
2652 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2653 : :
2654 [ + - ]: 1 : iMesh_createVtxArr( mesh, 2, iBase_INTERLEAVED, coords, 6, &verts, &verts_alloc, &verts_size, &err );
2655 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2656 : :
2657 [ + - ]: 1 : iMesh_createEnt( mesh, iMesh_LINE_SEGMENT, verts, 2, &line, &status, &err );
2658 [ + - ][ - + ]: 1 : if( iBase_SUCCESS != err || status != iBase_NEW ) return 0;
2659 : :
2660 [ + - ]: 1 : iMesh_getEntAdj( mesh, verts[0], iBase_ALL_TYPES, &adj, &adj_alloc, &adj_size, &err );
2661 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2662 [ + - ][ - + ]: 1 : if( adj_size != 1 || adj[0] != line )
2663 : : {
2664 [ # # ]: 0 : printf( "Bad: couldn't find adjacency for vertex\n" );
2665 : 0 : return 0;
2666 : : }
2667 : 1 : free( adj );
2668 : :
2669 : 1 : adj_alloc = 0;
2670 : 1 : adj = NULL;
2671 [ + - ]: 1 : iMesh_getEntAdj( mesh, line, iBase_ALL_TYPES, &adj, &adj_alloc, &adj_size, &err );
2672 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2673 [ + - ][ + - ]: 1 : if( adj_size != 2 ||
2674 [ - + ][ # # ]: 1 : ( ( adj[0] != verts[0] || adj[1] != verts[1] ) && ( adj[0] != verts[1] || adj[1] != verts[0] ) ) )
[ # # ]
2675 : : {
2676 [ # # ]: 0 : printf( "Bad: couldn't find adjacencies for line\n" );
2677 : 0 : free( adj );
2678 : 0 : free( verts );
2679 : 0 : return 0;
2680 : : }
2681 : 1 : free( adj );
2682 : 1 : free( verts );
2683 [ + - ]: 1 : iMesh_dtor( mesh, &err );
2684 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2685 : 1 : return 1;
2686 : : }
2687 : :
2688 : 1 : static int ordered_set_regression( iMesh_Instance mesh )
2689 : : {
2690 : 1 : double coords[] = { 0, 0, 0, 1, 1, 1 };
2691 : : iBase_EntityHandle line, *p, verts[2], ents_in[3], ents_out[3];
2692 : : iBase_EntitySetHandle set;
2693 : 1 : int i, err, status, two = 2, three = 3;
2694 : :
2695 [ + - ]: 1 : iMesh_newMesh( "", &mesh, &err, 0 );
2696 [ - + ][ # # ]: 1 : CHK( err );
2697 : 1 : p = verts;
2698 [ + - ]: 1 : iMesh_createVtxArr( mesh, 2, iBase_INTERLEAVED, coords, 6, &p, &two, &two, &err );
2699 [ - + ][ # # ]: 1 : CHK( err );
2700 [ + - ]: 1 : iMesh_createEnt( mesh, iMesh_LINE_SEGMENT, verts, 2, &line, &status, &err );
2701 [ - + ][ # # ]: 1 : CHK( err );
2702 [ - + ]: 1 : if( status != iBase_NEW ) return 0;
2703 [ + - ]: 1 : iMesh_createEntSet( mesh, 1, &set, &err );
2704 [ - + ][ # # ]: 1 : CHK( err );
2705 : 1 : ents_in[0] = verts[1];
2706 : 1 : ents_in[1] = line;
2707 : 1 : ents_in[2] = verts[0];
2708 [ + - ]: 1 : iMesh_addEntArrToSet( mesh, ents_in, three, set, &err );
2709 [ - + ][ # # ]: 1 : CHK( err );
2710 : 1 : p = ents_out;
2711 [ + - ]: 1 : iMesh_getEntities( mesh, set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &p, &three, &three, &err );
2712 [ - + ][ # # ]: 1 : CHK( err );
2713 [ + + ]: 4 : for( i = 0; i < three; i++ )
2714 : : {
2715 [ - + ]: 3 : if( ents_in[i] != ents_out[i] )
2716 : : {
2717 [ # # ]: 0 : printf( "Ordered set does not preserve order\n" );
2718 : 0 : return 0;
2719 : : }
2720 : : }
2721 [ + - ]: 1 : iMesh_dtor( mesh, &err );
2722 [ - + ][ # # ]: 1 : CHK( err );
2723 : 1 : return 1;
2724 : : }
2725 : :
2726 : 1 : int array_allocation( iMesh_Instance mesh )
2727 : : {
2728 : : int err;
2729 : :
2730 : 1 : double coords[] = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3 };
2731 : :
2732 : 1 : iBase_EntityHandle* verts = NULL;
2733 : 1 : int verts_alloc = 0, verts_size;
2734 : :
2735 : : iBase_EntityHandle* ents;
2736 : : int ents_alloc, ents_size;
2737 : :
2738 [ + - ]: 1 : iMesh_newMesh( "", &mesh, &err, 0 );
2739 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2740 : :
2741 [ + - ]: 1 : iMesh_getRootSet( mesh, &root_set, &err );
2742 [ - + ]: 1 : if( iBase_SUCCESS != err )
2743 : : {
2744 [ # # ]: 0 : printf( "Failed to return a root set.\n" );
2745 : 0 : return 0;
2746 : : }
2747 : :
2748 [ + - ]: 1 : iMesh_createVtxArr( mesh, 4, iBase_INTERLEAVED, coords, 12, &verts, &verts_alloc, &verts_size, &err );
2749 [ - + ]: 1 : if( iBase_SUCCESS != err ) return 0;
2750 : :
2751 : 1 : free( verts );
2752 : :
2753 : : /* test for proper allocation when array pointer passed in null but alloc'd size not */
2754 : 1 : ents_alloc = 3;
2755 : 1 : ents = NULL;
2756 [ + - ]: 1 : iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &ents, &ents_alloc, &ents_size, &err );
2757 [ - + ][ # # ]: 1 : CHK( err );
2758 : :
2759 : 1 : free( ents );
2760 : :
2761 : : /* test for proper allocation when array pointer passed in non-null but alloc'd size 0 */
2762 : 1 : ents_alloc = 0;
2763 [ + - ]: 1 : iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &ents, &ents_alloc, &ents_size, &err );
2764 [ - + ][ # # ]: 1 : CHK( err );
2765 : :
2766 : 1 : free( ents );
2767 : :
2768 : : /* test for failure when passed in alloc'd size is smaller than it should be */
2769 : 1 : ents_alloc -= 1;
2770 [ + - ]: 1 : iMesh_getEntities( mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &ents, &ents_alloc, &ents_size, &err );
2771 [ - + ][ # # ]: 1 : if( iBase_BAD_ARRAY_SIZE != err && iBase_BAD_ARRAY_DIMENSION != err )
2772 : : {
2773 : 0 : err = iBase_FAILURE;
2774 [ # # ][ # # ]: 0 : CHK( err );
2775 : : }
2776 : :
2777 [ + - ]: 1 : iMesh_dtor( mesh, &err );
2778 [ - + ][ # # ]: 1 : CHK( err );
2779 : :
2780 : 1 : return 1;
2781 : : }
2782 : :
2783 : 45 : int compare_single_iter( const char* info, iMesh_Instance mesh, iBase_EntitySetHandle set, iBase_EntityHandle* contents,
2784 : : int contents_size, enum iBase_EntityType type, enum iMesh_EntityTopology topo )
2785 : : {
2786 : 45 : iBase_EntityIterator iter = 0;
2787 : 45 : int i, twice, has_data, result = iBase_SUCCESS, result2;
2788 : : iBase_EntityHandle value;
2789 : :
2790 [ + - ]: 45 : iMesh_initEntIter( mesh, set, type, topo, 0, &iter, &result );
2791 [ - + ]: 45 : if( iBase_SUCCESS != result )
2792 : : {
2793 : : printf( "%s:%d: Error %d initializing %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
2794 [ # # ]: 0 : (int)type, (int)topo );
2795 : 0 : return result;
2796 : : }
2797 : :
2798 [ + + ]: 135 : for( twice = 0; twice < 2; ++twice )
2799 : : {
2800 : :
2801 [ + + ]: 41402 : for( i = 0; i < contents_size; ++i )
2802 : : {
2803 [ + - ]: 41312 : iMesh_getNextEntIter( mesh, iter, &value, &has_data, &result );
2804 [ - + ]: 41312 : if( iBase_SUCCESS != result )
2805 : : {
2806 : : printf( "%s:%d: Error %d stepping %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
2807 [ # # ]: 0 : (int)type, (int)topo );
2808 : 0 : goto end_single_iter;
2809 : : }
2810 : :
2811 [ - + ]: 41312 : if( !has_data )
2812 : : {
2813 : : printf( "%s:%d: %s iterator for type %d/topo %d ended prematurely at %d of %d\n", __FILE__, __LINE__,
2814 [ # # ]: 0 : info, (int)type, (int)topo, i, contents_size );
2815 : 0 : result = iBase_FAILURE;
2816 : 0 : goto end_single_iter;
2817 : : }
2818 : :
2819 [ - + ]: 41312 : if( value != contents[i] )
2820 : : {
2821 : : printf( "%s:%d: %s iterator for type %d/topo %d returned incorrect value at %d of %d\n", __FILE__,
2822 [ # # ]: 0 : __LINE__, info, (int)type, (int)topo, i, contents_size );
2823 : 0 : result = iBase_FAILURE;
2824 : 0 : goto end_single_iter;
2825 : : }
2826 : : }
2827 : :
2828 [ + - ]: 90 : iMesh_getNextEntIter( mesh, iter, &value, &has_data, &result );
2829 [ - + ]: 90 : if( iBase_SUCCESS != result )
2830 : : {
2831 : : printf( "%s:%d: Error %d stepping %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
2832 [ # # ]: 0 : (int)type, (int)topo );
2833 : 0 : goto end_single_iter;
2834 : : }
2835 : :
2836 [ - + ]: 90 : if( has_data )
2837 : : {
2838 : : printf( "%s:%d: %s iterator for type %d/topo %d did not end after %d values\n", __FILE__, __LINE__, info,
2839 [ # # ]: 0 : (int)type, (int)topo, contents_size );
2840 : 0 : result = iBase_FAILURE;
2841 : 0 : goto end_single_iter;
2842 : : }
2843 : :
2844 [ + - ]: 90 : iMesh_resetEntIter( mesh, iter, &result );
2845 [ - + ]: 90 : if( iBase_SUCCESS != result )
2846 : : {
2847 : : printf( "%s:%d: Error %d resetting %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
2848 [ # # ]: 0 : (int)type, (int)topo );
2849 : 0 : result = iBase_FAILURE;
2850 : 0 : goto end_single_iter;
2851 : : }
2852 : : }
2853 : :
2854 : : end_single_iter:
2855 [ + - ]: 45 : iMesh_endEntIter( mesh, iter, &result2 );
2856 [ - + ]: 45 : if( iBase_SUCCESS != result2 )
2857 : : {
2858 : : printf( "%s:%d: Error %d releasing %s iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
2859 [ # # ]: 0 : (int)type, (int)topo );
2860 [ # # ]: 0 : if( iBase_SUCCESS == result ) result = result2;
2861 : : }
2862 : 45 : return result;
2863 : : }
2864 : :
2865 : 45 : int compare_array_iter( const char* info, iMesh_Instance mesh, iBase_EntitySetHandle set, iBase_EntityHandle* contents,
2866 : : int contents_size, int array_size, enum iBase_EntityType type, enum iMesh_EntityTopology topo )
2867 : : {
2868 : 45 : iBase_EntityArrIterator iter = 0;
2869 : 45 : int i, j, twice, has_data, result = iBase_SUCCESS, result2;
2870 : : iBase_EntityHandle* values;
2871 : 45 : int values_size, values_alloc = array_size;
2872 : 45 : values = (iBase_EntityHandle*)malloc( array_size * sizeof( iBase_EntityHandle ) );
2873 : :
2874 [ + - ]: 45 : iMesh_initEntArrIter( mesh, set, type, topo, array_size, 0, &iter, &result );
2875 [ - + ]: 45 : if( iBase_SUCCESS != result )
2876 : : {
2877 : : printf( "%s:%d: Error %d initializing %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result,
2878 [ # # ]: 0 : info, (int)type, (int)topo );
2879 : 0 : free( values );
2880 : 0 : return result;
2881 : : }
2882 : :
2883 [ + + ]: 135 : for( twice = 0; twice < 2; ++twice )
2884 : : {
2885 : 90 : i = 0;
2886 [ + + ]: 11492 : while( i < contents_size )
2887 : : {
2888 : :
2889 [ + - ]: 11402 : iMesh_getNextEntArrIter( mesh, iter, &values, &values_alloc, &values_size, &has_data, &result );
2890 [ - + ]: 11402 : if( iBase_SUCCESS != result )
2891 : : {
2892 : : printf( "%s:%d: Error %d stepping %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result,
2893 [ # # ]: 0 : info, (int)type, (int)topo );
2894 : 0 : goto end_arr_iter;
2895 : : }
2896 : :
2897 [ + - ][ - + ]: 11402 : if( !has_data || !values_size )
2898 : : {
2899 : : printf( "%s:%d: %s array iterator for type %d/topo %d ended prematurely at %d of %d\n", __FILE__,
2900 [ # # ]: 0 : __LINE__, info, (int)type, (int)topo, i, contents_size );
2901 : 0 : result = iBase_FAILURE;
2902 : 0 : goto end_arr_iter;
2903 : : }
2904 : :
2905 [ - + ]: 11402 : if( i + values_size > contents_size )
2906 : : {
2907 : : printf( "%s:%d: %s array iterator for type %d/topo %d returned more than %d handles\n", __FILE__,
2908 [ # # ]: 0 : __LINE__, info, (int)type, (int)topo, contents_size );
2909 : 0 : result = iBase_FAILURE;
2910 : 0 : goto end_arr_iter;
2911 : : }
2912 : :
2913 [ + + ][ - + ]: 11402 : if( contents_size - i >= array_size && values_size < array_size )
2914 : : {
2915 : : printf( "%s:%d: %s array iterator for type %d/topo %d returned fewer than %d handles\n", __FILE__,
2916 [ # # ]: 0 : __LINE__, info, (int)type, (int)topo, array_size );
2917 : 0 : result = iBase_FAILURE;
2918 : 0 : goto end_arr_iter;
2919 : : }
2920 : :
2921 [ + + ]: 52714 : for( j = 0; j < values_size; ++j, ++i )
2922 : : {
2923 [ - + ]: 41312 : if( values[j] != contents[i] )
2924 : : {
2925 : : printf( "%s:%d: %s array iterator for type %d/topo %d returned incorrect value "
2926 : : "at %d of %d\n",
2927 [ # # ]: 0 : __FILE__, __LINE__, info, (int)type, (int)topo, i, contents_size );
2928 : 0 : result = iBase_FAILURE;
2929 : 0 : goto end_arr_iter;
2930 : : }
2931 : : }
2932 : : }
2933 : :
2934 [ + - ]: 90 : iMesh_getNextEntArrIter( mesh, iter, &values, &values_alloc, &values_size, &has_data, &result );
2935 [ - + ]: 90 : if( iBase_SUCCESS != result )
2936 : : {
2937 : : printf( "%s:%d: Error %d stepping %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result,
2938 [ # # ]: 0 : info, (int)type, (int)topo );
2939 : 0 : goto end_arr_iter;
2940 : : }
2941 : :
2942 [ + - ][ - + ]: 90 : if( has_data || values_size )
2943 : : {
2944 : : printf( "%s:%d: %s array iterator for type %d/topo %d did not end after %d values\n", __FILE__, __LINE__,
2945 [ # # ]: 0 : info, (int)type, (int)topo, contents_size );
2946 : 0 : result = iBase_FAILURE;
2947 : 0 : goto end_arr_iter;
2948 : : }
2949 : :
2950 [ + - ]: 90 : iMesh_resetEntArrIter( mesh, iter, &result );
2951 [ - + ]: 90 : if( iBase_SUCCESS != result )
2952 : : {
2953 : : printf( "%s:%d: Error %d resetting %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result,
2954 [ # # ]: 0 : info, (int)type, (int)topo );
2955 : 0 : result = iBase_FAILURE;
2956 : 0 : goto end_arr_iter;
2957 : : }
2958 : : }
2959 : :
2960 : : end_arr_iter:
2961 : 45 : free( values );
2962 [ + - ]: 45 : iMesh_endEntArrIter( mesh, iter, &result2 );
2963 [ - + ]: 45 : if( iBase_SUCCESS != result2 )
2964 : : {
2965 : : printf( "%s:%d: Error %d releasing %s array iterator for type %d/topo %d\n", __FILE__, __LINE__, result, info,
2966 [ # # ]: 0 : (int)type, (int)topo );
2967 [ # # ]: 0 : if( iBase_SUCCESS == result ) result = result2;
2968 : : }
2969 : 45 : return result;
2970 : : }
2971 : :
2972 : 90 : int test_iterator_common( const char* info, iMesh_Instance mesh, iBase_EntitySetHandle set, int array_size,
2973 : : enum iBase_EntityType type, enum iMesh_EntityTopology topo )
2974 : : {
2975 : 90 : iBase_EntityHandle* contents = NULL;
2976 : 90 : int content_size = 0, content_alloc = 0;
2977 : : int result;
2978 : :
2979 [ + - ]: 90 : iMesh_getEntities( mesh, set, type, topo, &contents, &content_alloc, &content_size, &result );
2980 [ - + ][ # # ]: 90 : CHK( result );
2981 [ + + ]: 90 : if( array_size == 1 )
2982 [ + - ]: 45 : result = compare_single_iter( info, mesh, set, contents, content_size, type, topo );
2983 : : else
2984 [ + - ]: 45 : result = compare_array_iter( info, mesh, set, contents, content_size, array_size, type, topo );
2985 : 90 : free( contents );
2986 : 90 : return result;
2987 : : }
2988 : :
2989 : 1 : int test_iterator( iMesh_Instance mesh )
2990 : : {
2991 : : int result, i;
2992 : : iBase_EntitySetHandle root, list, set, *setptr;
2993 : 1 : iBase_EntityHandle* array = NULL;
2994 : 1 : int array_len = 0, array_size = 0;
2995 : :
2996 [ + - ]: 1 : iMesh_getRootSet( mesh, &root, &result );
2997 [ - + ][ # # ]: 1 : CHK( result );
2998 : :
2999 : : /* create some sets containing every other handle */
3000 [ + - ]: 1 : iMesh_getEntities( mesh, root, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &array, &array_size, &array_len, &result );
3001 [ - + ][ # # ]: 1 : CHK( result );
3002 [ + + ]: 2066 : for( i = 1; i < array_size; i += 2 )
3003 : 2065 : array[i] = array[i - 1];
3004 [ + + ]: 3 : for( i = 0; i < 2; ++i )
3005 : : {
3006 [ + + ]: 2 : setptr = i ? &list : &set;
3007 [ + - ]: 2 : iMesh_createEntSet( mesh, i, setptr, &result );
3008 [ - + ]: 2 : if( iBase_SUCCESS != result ) free( array );
3009 [ - + ][ # # ]: 2 : CHK( result );
3010 [ + - ]: 2 : iMesh_addEntArrToSet( mesh, array, array_size, *setptr, &result );
3011 [ - + ]: 2 : if( iBase_SUCCESS != result ) free( array );
3012 [ - + ][ # # ]: 2 : CHK( result );
3013 : : }
3014 : 1 : free( array );
3015 : :
3016 : : /* test single iterator and array iterator for all types */
3017 [ + + ]: 5 : for( i = 0; i < iBase_ALL_TYPES; ++i )
3018 : : {
3019 : 4 : array_size = 2 * i + 2;
3020 [ + - ]: 4 : result = test_iterator_common( "root", mesh, root, 1, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
3021 [ - + ][ # # ]: 4 : CHK( result );
3022 [ + - ]: 4 : result = test_iterator_common( "root", mesh, root, array_size, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
3023 [ - + ][ # # ]: 4 : CHK( result );
3024 [ + - ]: 4 : result = test_iterator_common( "list", mesh, list, 1, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
3025 [ - + ][ # # ]: 4 : CHK( result );
3026 [ + - ]: 4 : result = test_iterator_common( "list", mesh, list, array_size, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
3027 [ - + ][ # # ]: 4 : CHK( result );
3028 [ + - ]: 4 : result = test_iterator_common( "set", mesh, set, 1, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
3029 [ - + ][ # # ]: 4 : CHK( result );
3030 [ + - ]: 4 : result = test_iterator_common( "set", mesh, set, array_size, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
3031 [ - + ][ # # ]: 4 : CHK( result );
3032 : : }
3033 : :
3034 : : /* test single iterator and array iterator for all types */
3035 [ + + ]: 12 : for( i = 0; i < iMesh_ALL_TOPOLOGIES; ++i )
3036 : : {
3037 : 11 : array_size = 2 * i + 2;
3038 [ + - ]: 11 : result = test_iterator_common( "root", mesh, root, 1, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
3039 [ - + ][ # # ]: 11 : CHK( result );
3040 [ + - ]: 11 : result = test_iterator_common( "root", mesh, root, array_size, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
3041 [ - + ][ # # ]: 11 : CHK( result );
3042 [ + - ]: 11 : result = test_iterator_common( "list", mesh, list, 1, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
3043 [ - + ][ # # ]: 11 : CHK( result );
3044 [ + - ]: 11 : result = test_iterator_common( "list", mesh, list, array_size, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
3045 [ - + ][ # # ]: 11 : CHK( result );
3046 [ + - ]: 11 : result = test_iterator_common( "set", mesh, set, 1, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
3047 [ - + ][ # # ]: 11 : CHK( result );
3048 [ + - ]: 11 : result = test_iterator_common( "set", mesh, set, array_size, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
3049 [ - + ][ # # ]: 11 : CHK( result );
3050 : : }
3051 : :
3052 : 1 : return 1;
3053 : : }
3054 : :
3055 : 1 : int main( int argc, char* argv[] )
3056 : : {
3057 : : /* Check command line arg */
3058 : : const char* filename;
3059 : 1 : int number_tests = 0;
3060 : 1 : int number_tests_successful = 0;
3061 : 1 : int number_tests_not_implemented = 0;
3062 : 1 : int number_tests_failed = 0;
3063 : : int result;
3064 : 1 : iMesh_Instance mesh = NULL;
3065 : :
3066 [ - + ]: 1 : if( argc == 2 ) { filename = argv[1]; }
3067 : : else
3068 : : {
3069 [ + - ]: 1 : printf( "Usage: %s <mesh_filename>\n", argv[0] );
3070 [ - + ]: 1 : if( argc != 1 ) return 1;
3071 [ + - ]: 1 : printf( " No file specified. Defaulting to: %s\n", DEFAULT_INPUT_FILE );
3072 : 1 : filename = DEFAULT_INPUT_FILE;
3073 : : }
3074 : :
3075 : : /* initialize the Mesh */
3076 [ + - ]: 1 : iMesh_newMesh( NULL, &mesh, &result, 0 );
3077 [ - + ]: 1 : if( iBase_SUCCESS != result )
3078 : : {
3079 [ # # ]: 0 : printf( "Failed to create a mesh instance.\n" );
3080 : 0 : return 1;
3081 : : }
3082 [ + - ]: 1 : iMesh_getRootSet( mesh, &root_set, &result );
3083 [ - + ]: 1 : if( iBase_SUCCESS != result )
3084 : : {
3085 [ # # ]: 0 : printf( "Failed to return a root set.\n" );
3086 : 0 : return 1;
3087 : : }
3088 : :
3089 : : /* Print out Header information */
3090 [ + - ]: 1 : printf( "\n\nTSTT TEST PROGRAM:\n\n" );
3091 : :
3092 : : /* load_mesh test */
3093 [ + - ]: 1 : printf( " load_mesh: " );
3094 [ + - ]: 1 : result = load_mesh_test( filename, mesh );
3095 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3096 : 1 : number_tests++;
3097 [ + - ]: 1 : printf( "\n" );
3098 : :
3099 : : /* topology_adjacency_test */
3100 [ + - ]: 1 : printf( " topology_adjacency_test: " );
3101 [ + - ]: 1 : result = topology_adjacency_test( mesh );
3102 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3103 : 1 : number_tests++;
3104 [ + - ]: 1 : printf( "\n" );
3105 : :
3106 : : /* entity connectivity test */
3107 [ + - ]: 1 : printf( " entity_connectivity_test: " );
3108 [ + - ]: 1 : result = entity_connectivity_test( mesh );
3109 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3110 : 1 : number_tests++;
3111 [ + - ]: 1 : printf( "\n" );
3112 : :
3113 : : /* vertex_coordinates_test */
3114 [ + - ]: 1 : printf( " vertex_coordinates_test: " );
3115 [ + - ]: 1 : result = vertex_coordinates_test( mesh );
3116 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3117 : 1 : number_tests++;
3118 [ + - ]: 1 : printf( "\n" );
3119 : :
3120 : : /* topology dimension test */
3121 [ + - ]: 1 : printf( " topology_dimension_test: " );
3122 [ + - ]: 1 : result = topology_dimension_test( mesh );
3123 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3124 : 1 : number_tests++;
3125 [ + - ]: 1 : printf( "\n" );
3126 : :
3127 : : /* entity sets test */
3128 [ + - ]: 1 : printf( " entity_sets_test: " );
3129 [ + - ]: 1 : result = entity_sets_test( mesh );
3130 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3131 : 1 : number_tests++;
3132 [ + - ]: 1 : printf( "\n" );
3133 : :
3134 : : /* vertex tag test */
3135 [ + - ]: 1 : printf( " vertex_tag_test: " );
3136 [ + - ]: 1 : result = vertex_tag_test( mesh );
3137 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3138 : 1 : number_tests++;
3139 [ + - ]: 1 : printf( "\n" );
3140 : :
3141 : : /* entityset tag test */
3142 [ + - ]: 1 : printf( " entityset_tag_test: " );
3143 [ + - ]: 1 : result = entityset_tag_test( mesh );
3144 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3145 : 1 : number_tests++;
3146 [ + - ]: 1 : printf( "\n" );
3147 : :
3148 : : /* mesh tag test */
3149 [ + - ]: 1 : printf( " mesh_tag_test: " );
3150 [ + - ]: 1 : result = mesh_tag_test( mesh );
3151 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3152 : 1 : number_tests++;
3153 [ + - ]: 1 : printf( "\n" );
3154 : :
3155 : : /* iterator test */
3156 [ + - ]: 1 : printf( " test_iterator: " );
3157 [ + - ]: 1 : result = test_iterator( mesh );
3158 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3159 : 1 : number_tests++;
3160 [ + - ]: 1 : printf( "\n" );
3161 : :
3162 : : /* regression test for remove/contained bug */
3163 [ + - ]: 1 : printf( " set_remove_contained_regression: " );
3164 [ + - ]: 1 : result = set_remove_contained_regression( mesh );
3165 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3166 : 1 : number_tests++;
3167 [ + - ]: 1 : printf( "\n" );
3168 : :
3169 : : /* regression test for adjacencies with iBase_ALL_TYPES bug */
3170 [ + - ]: 1 : printf( " all_adjacency_regression: " );
3171 [ + - ]: 1 : result = all_adjacency_regression( mesh );
3172 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3173 : 1 : number_tests++;
3174 [ + - ]: 1 : printf( "\n" );
3175 : :
3176 : : /* test for error codes */
3177 [ + - ]: 1 : printf( " error_code_test: " );
3178 [ + - ]: 1 : result = error_code_test( mesh );
3179 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3180 : 1 : number_tests++;
3181 [ + - ]: 1 : printf( "\n" );
3182 : :
3183 : : /* regression test for ordered sets not preserving order */
3184 [ + - ]: 1 : printf( " ordered_set_regression: " );
3185 [ + - ]: 1 : result = ordered_set_regression( mesh );
3186 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3187 : 1 : number_tests++;
3188 [ + - ]: 1 : printf( "\n" );
3189 : :
3190 : : /* test for array allocation behavior */
3191 [ + - ]: 1 : printf( " array_allocation_regression: " );
3192 [ + - ]: 1 : result = array_allocation( mesh );
3193 [ + - ]: 1 : handle_error_code( result, &number_tests_failed, &number_tests_not_implemented, &number_tests_successful );
3194 : 1 : number_tests++;
3195 [ + - ]: 1 : printf( "\n" );
3196 : :
3197 : : /* summary */
3198 : :
3199 [ + - ]: 1 : printf( "\nTSTT TEST SUMMARY: \n" );
3200 : :
3201 [ + - ]: 1 : printf( " Number Tests: %d\n", number_tests );
3202 [ + - ]: 1 : printf( " Number Successful: %d\n", number_tests_successful );
3203 [ + - ]: 1 : printf( " Number Not Implemented: %d\n", number_tests_not_implemented );
3204 [ + - ]: 1 : printf( " Number Failed: %d\n", number_tests_failed );
3205 [ + - ]: 1 : printf( "\n\n\n" );
3206 : :
3207 : : /* delete the mesh */
3208 [ + - ]: 1 : iMesh_dtor( mesh, &result );
3209 [ - + ]: 1 : if( iBase_SUCCESS != result )
3210 : : {
3211 [ # # ]: 0 : printf( "Failed to destruct the mesh instance.\n" );
3212 : 0 : return 1;
3213 : : }
3214 : :
3215 : 1 : return number_tests_failed;
3216 [ + - ][ + - ]: 4 : }
|
