MOAB: Mesh Oriented datABase  (version 5.5.0)
Test_MBMeshSet.cpp
Go to the documentation of this file.
1 #include "MeshSet.hpp"
2 #include "AEntityFactory.hpp"
3 #include "TestUtil.hpp"
4 #include "moab/Core.hpp"
5 #include "moab/SetIterator.hpp"
6 
7 using namespace moab;
8 
9 #include <iostream>
10 
11 //! test add_entities, get_entities, num_entities
12 void test_add_entities( unsigned flags );
13 //! test remove_entities, get_entities, num_entities
14 void test_remove_entities( unsigned flags );
15 //! test get_entities_by_type, num_entities_by_type
16 void test_entities_by_type( unsigned flags );
17 //! test get_entities_by_dimension, num_entities_by_dimension
18 void test_entities_by_dimension( unsigned flags );
19 //! test subtract_meshset
20 void test_subtract( unsigned flags1, unsigned flags2 );
21 //! test intersect_meshset
22 void test_intersect( unsigned flags1, unsigned flags2 );
23 //! test unite_meshset
24 void test_unite( unsigned flags1, unsigned flags2 );
25 //! test MeshSet::contains_entities
26 void test_contains_entities( unsigned flags );
27 //! test clear_meshset
28 void test_clear( unsigned flags );
29 
30 //! Create 10x10x10 hex mesh
31 void make_mesh( Interface& iface );
32 //! Create 10x10x10 hex mesh, return ranges of handles
33 void make_mesh( Interface& iface, EntityHandle& vstart, EntityHandle& vend, EntityHandle& hstart, EntityHandle& hend );
34 //! Print std::vector<EntityHandle>
35 void print_handle_vect( const char* prefix, const std::vector< EntityHandle >& vect );
36 //! Print Range
37 void print_mbrange( const char* prefix, const Range& range );
38 //! Compare set contents against passed vector, and if MESHSET_TRACK_OWNER then check adjacencies
39 bool check_set_contents( Core& mb, EntityHandle set, const std::vector< EntityHandle >& expected );
40 //! Compare result of get_entities_by_type to result of get_entities_by_handle
41 bool check_set_contents( Core& mb, EntityType type, EntityHandle set, unsigned flags );
42 //! Compare result of get_entities_by_dimension to result of get_entities_by_handle
43 bool check_set_contents( Core& mb, int dim, EntityHandle set, unsigned flags );
44 //! For each entry in range, if one or more occurances in vect, remove last occurance from vect.
45 void remove_from_back( std::vector< EntityHandle >& vect, const Range& range );
46 enum BoolOp
47 {
48  UNITE,
49  INTERSECT,
50  SUBTRACT
51 };
52 //! Perform boolean op on two entity sets and verify result
53 bool test_boolean( Core& mb,
54  BoolOp op,
55  unsigned flags1,
56  const Range& set1_ents,
57  unsigned flags2,
58  const Range& set2_ents );
59 void test_iterator( Interface& moab, SetIterator* iter, EntityHandle set, EntityType etype, int dim );
60 void test_iterators( unsigned int flags, bool type, bool dim );
61 void test_all_iterators();
62 
63 void test_add_entities_ordered()
64 {
65  test_add_entities( MESHSET_ORDERED );
66 }
67 void test_add_entities_set()
68 {
69  test_add_entities( MESHSET_SET );
70 }
71 void test_add_entities_ordered_tracking()
72 {
73  test_add_entities( MESHSET_TRACK_OWNER | MESHSET_ORDERED );
74 }
75 void test_add_entities_set_tracking()
76 {
77  test_add_entities( MESHSET_TRACK_OWNER | MESHSET_SET );
78 }
79 
80 void test_remove_entities_ordered()
81 {
82  test_remove_entities( MESHSET_ORDERED );
83 }
84 void test_remove_entities_set()
85 {
86  test_remove_entities( MESHSET_SET );
87 }
88 void test_remove_entities_ordered_tracking()
89 {
90  test_remove_entities( MESHSET_TRACK_OWNER | MESHSET_ORDERED );
91 }
92 void test_remove_entities_set_tracking()
93 {
94  test_remove_entities( MESHSET_TRACK_OWNER | MESHSET_SET );
95 }
96 
97 void test_entities_by_type_ordered()
98 {
99  test_entities_by_type( MESHSET_ORDERED );
100 }
101 void test_entities_by_type_set()
102 {
103  test_entities_by_type( MESHSET_SET );
104 }
105 void test_entities_by_dim_ordered()
106 {
107  test_entities_by_dimension( MESHSET_ORDERED );
108 }
109 void test_entities_by_dim_set()
110 {
111  test_entities_by_dimension( MESHSET_SET );
112 }
113 
114 void test_subtract_set_set()
115 {
116  test_subtract( MESHSET_SET, MESHSET_SET );
117 }
118 void test_subtract_set_ordered()
119 {
120  test_subtract( MESHSET_SET, MESHSET_ORDERED );
121 }
122 void test_subtract_ordered_set()
123 {
124  test_subtract( MESHSET_ORDERED, MESHSET_SET );
125 }
126 void test_subtract_ordered_ordered()
127 {
128  test_subtract( MESHSET_ORDERED, MESHSET_ORDERED );
129 }
130 void test_subtract_set_set_tracking()
131 {
132  test_subtract( MESHSET_TRACK_OWNER | MESHSET_SET, MESHSET_TRACK_OWNER | MESHSET_SET );
133 }
134 void test_subtract_set_ordered_tracking()
135 {
136  test_subtract( MESHSET_TRACK_OWNER | MESHSET_SET, MESHSET_TRACK_OWNER | MESHSET_ORDERED );
137 }
138 void test_subtract_ordered_set_tracking()
139 {
140  test_subtract( MESHSET_TRACK_OWNER | MESHSET_ORDERED, MESHSET_TRACK_OWNER | MESHSET_SET );
141 }
142 void test_subtract_ordered_ordered_tracking()
143 {
144  test_subtract( MESHSET_TRACK_OWNER | MESHSET_ORDERED, MESHSET_TRACK_OWNER | MESHSET_ORDERED );
145 }
146 
147 void test_itersect_set_set()
148 {
149  test_intersect( MESHSET_SET, MESHSET_SET );
150 }
151 void test_itersect_set_ordered()
152 {
153  test_intersect( MESHSET_SET, MESHSET_ORDERED );
154 }
155 void test_itersect_ordered_set()
156 {
157  test_intersect( MESHSET_ORDERED, MESHSET_SET );
158 }
159 void test_itersect_ordered_ordered()
160 {
161  test_intersect( MESHSET_ORDERED, MESHSET_ORDERED );
162 }
163 void test_itersect_set_set_tracking()
164 {
165  test_intersect( MESHSET_TRACK_OWNER | MESHSET_SET, MESHSET_TRACK_OWNER | MESHSET_SET );
166 }
167 void test_itersect_set_ordered_tracking()
168 {
169  test_intersect( MESHSET_TRACK_OWNER | MESHSET_SET, MESHSET_TRACK_OWNER | MESHSET_ORDERED );
170 }
171 void test_itersect_ordered_set_tracking()
172 {
173  test_intersect( MESHSET_TRACK_OWNER | MESHSET_ORDERED, MESHSET_TRACK_OWNER | MESHSET_SET );
174 }
175 void test_itersect_ordered_ordered_tracking()
176 {
177  test_intersect( MESHSET_TRACK_OWNER | MESHSET_ORDERED, MESHSET_TRACK_OWNER | MESHSET_ORDERED );
178 }
179 
180 void test_unite_set_set()
181 {
182  test_unite( MESHSET_SET, MESHSET_SET );
183 }
184 void test_unite_set_ordered()
185 {
186  test_unite( MESHSET_SET, MESHSET_ORDERED );
187 }
188 void test_unite_ordered_set()
189 {
190  test_unite( MESHSET_ORDERED, MESHSET_SET );
191 }
192 void test_unite_ordered_ordered()
193 {
194  test_unite( MESHSET_ORDERED, MESHSET_ORDERED );
195 }
196 void test_unite_set_set_tracking()
197 {
198  test_unite( MESHSET_TRACK_OWNER | MESHSET_SET, MESHSET_TRACK_OWNER | MESHSET_SET );
199 }
200 void test_unite_set_ordered_tracking()
201 {
202  test_unite( MESHSET_TRACK_OWNER | MESHSET_SET, MESHSET_TRACK_OWNER | MESHSET_ORDERED );
203 }
204 void test_unite_ordered_set_tracking()
205 {
206  test_unite( MESHSET_TRACK_OWNER | MESHSET_ORDERED, MESHSET_TRACK_OWNER | MESHSET_SET );
207 }
208 void test_unite_ordered_ordered_tracking()
209 {
210  test_unite( MESHSET_TRACK_OWNER | MESHSET_ORDERED, MESHSET_TRACK_OWNER | MESHSET_ORDERED );
211 }
212 
213 void test_contains_entities_ordered()
214 {
215  test_contains_entities( MESHSET_ORDERED );
216 }
217 void test_contains_entities_set()
218 {
219  test_contains_entities( MESHSET_SET );
220 }
221 
222 void test_clear_ordered()
223 {
224  test_clear( MESHSET_ORDERED );
225 }
226 void test_clear_set()
227 {
228  test_clear( MESHSET_SET );
229 }
230 void test_clear_ordered_tracking()
231 {
232  test_clear( MESHSET_TRACK_OWNER | MESHSET_ORDERED );
233 }
234 void test_clear_set_tracking()
235 {
236  test_clear( MESHSET_TRACK_OWNER | MESHSET_SET );
237 }
238 
239 // Reproduce contitions that resulted in bug reported to
240 // mailing list:
241 // http://lists.mcs.anl.gov/pipermail/moab-dev/2010/002714.html
242 void regression_insert_set_1();
243 
244 int main()
245 {
246  int err = 0;
247 
248  err += RUN_TEST( test_add_entities_ordered );
249  err += RUN_TEST( test_add_entities_set );
250  err += RUN_TEST( test_add_entities_ordered_tracking );
251  err += RUN_TEST( test_add_entities_set_tracking );
252 
253  err += RUN_TEST( test_remove_entities_ordered );
254  err += RUN_TEST( test_remove_entities_set );
255  err += RUN_TEST( test_remove_entities_ordered_tracking );
256  err += RUN_TEST( test_remove_entities_set_tracking );
257 
258  err += RUN_TEST( test_entities_by_type_ordered );
259  err += RUN_TEST( test_entities_by_type_set );
260  err += RUN_TEST( test_entities_by_dim_ordered );
261  err += RUN_TEST( test_entities_by_dim_set );
262 
263  err += RUN_TEST( test_subtract_set_set );
264  err += RUN_TEST( test_subtract_set_ordered );
265  err += RUN_TEST( test_subtract_ordered_set );
266  err += RUN_TEST( test_subtract_ordered_ordered );
267  err += RUN_TEST( test_subtract_set_set_tracking );
268  err += RUN_TEST( test_subtract_set_ordered_tracking );
269  err += RUN_TEST( test_subtract_ordered_set_tracking );
270  err += RUN_TEST( test_subtract_ordered_ordered_tracking );
271 
272  err += RUN_TEST( test_itersect_set_set );
273  err += RUN_TEST( test_itersect_set_ordered );
274  err += RUN_TEST( test_itersect_ordered_set );
275  err += RUN_TEST( test_itersect_ordered_ordered );
276  err += RUN_TEST( test_itersect_set_set_tracking );
277  err += RUN_TEST( test_itersect_set_ordered_tracking );
278  err += RUN_TEST( test_itersect_ordered_set_tracking );
279  err += RUN_TEST( test_itersect_ordered_ordered_tracking );
280 
281  err += RUN_TEST( test_unite_set_set );
282  err += RUN_TEST( test_unite_set_ordered );
283  err += RUN_TEST( test_unite_ordered_set );
284  err += RUN_TEST( test_unite_ordered_ordered );
285  err += RUN_TEST( test_unite_set_set_tracking );
286  err += RUN_TEST( test_unite_set_ordered_tracking );
287  err += RUN_TEST( test_unite_ordered_set_tracking );
288  err += RUN_TEST( test_unite_ordered_ordered_tracking );
289 
290  err += RUN_TEST( test_contains_entities_ordered );
291  err += RUN_TEST( test_contains_entities_set );
292 
293  err += RUN_TEST( test_clear_ordered );
294  err += RUN_TEST( test_clear_set );
295  err += RUN_TEST( test_clear_ordered_tracking );
296  err += RUN_TEST( test_clear_set_tracking );
297 
298  err += RUN_TEST( regression_insert_set_1 );
299 
300  err += RUN_TEST( test_all_iterators );
301 
302  if( !err )
303  printf( "ALL TESTS PASSED\n" );
304  else
305  printf( "%d TESTS FAILED\n", err );
306 
307  return err;
308 }
309 
310 // Create 100x100x100 hex mesh
311 void make_mesh( Interface& iface )
312 {
313  const int dim = 10;
314 
315  // create vertices
316  EntityHandle prev_handle = 0;
317  for( int z = 0; z <= dim; ++z )
318  {
319  for( int y = 0; y <= dim; ++y )
320  {
321  for( int x = 0; x <= dim; ++x )
322  {
323  const double coords[] = { static_cast< double >( x ), static_cast< double >( y ),
324  static_cast< double >( z ) };
325  EntityHandle new_handle = 0;
326  ErrorCode rval = iface.create_vertex( coords, new_handle );CHECK_ERR( rval );
327  CHECK_EQUAL( ++prev_handle, new_handle );
328  }
329  }
330  }
331 
332  // create hexes
333  const int dim1 = dim + 1;
334  const int dimq = dim1 * dim1;
335  prev_handle = FIRST_HANDLE( MBHEX );
336  for( int z = 0; z < dim; ++z )
337  {
338  for( int y = 0; y < dim; ++y )
339  {
340  for( int x = 0; x < dim; ++x )
341  {
342  const EntityHandle off = 1 + x + dim1 * y + dimq * z;
343  const EntityHandle conn[] = { off, off + 1, off + 1 + dim1, off + dim1,
344  off + dimq, off + 1 + dimq, off + 1 + dim1 + dimq, off + dim1 + dimq };
345  EntityHandle new_handle = 0;
346  ErrorCode rval = iface.create_element( MBHEX, conn, 8, new_handle );CHECK_ERR( rval );
347  CHECK_EQUAL( prev_handle++, new_handle );
348  }
349  }
350  }
351 }
352 
353 void make_mesh( Interface& mb,
354  EntityHandle& first_vert,
355  EntityHandle& last_vert,
356  EntityHandle& first_hex,
357  EntityHandle& last_hex )
358 {
359  make_mesh( mb );
360 
361  // Get handle ranges, and validate assumption that handles
362  // are contiguous.
363  Range range;
364  ErrorCode rval = mb.get_entities_by_type( 0, MBVERTEX, range );CHECK_ERR( rval );
365  first_vert = range.front();
366  last_vert = range.back();
367  CHECK_EQUAL( (EntityHandle)1331, last_vert - first_vert + 1 );
368  range.clear();
369  rval = mb.get_entities_by_type( 0, MBHEX, range );CHECK_ERR( rval );
370  first_hex = range.front();
371  last_hex = range.back();
372  CHECK_EQUAL( (EntityHandle)1000, last_hex - first_hex + 1 );
373 }
374 
375 template < typename iter_type >
376 void print_handles( std::ostream& str, const char* prefix, iter_type begin, iter_type end )
377 {
378  if( prefix ) str << prefix << ':';
379  if( begin == end )
380  {
381  str << " (empty)" << std::endl;
382  return;
383  }
384 
385  iter_type i = begin;
386  EntityType prev_type = TYPE_FROM_HANDLE( *i );
387  EntityHandle prev_ent = *i;
388  str << ' ' << CN::EntityTypeName( prev_type ) << ' ' << ID_FROM_HANDLE( *i );
389  for( ;; )
390  {
391  iter_type j = i;
392  for( ++j, ++prev_ent; j != end && *j == prev_ent; ++j, ++prev_ent )
393  ;
394  --prev_ent;
395  if( prev_ent - *i > 1 )
396  str << "-" << ID_FROM_HANDLE( prev_ent );
397  else if( prev_ent - *i == 1 )
398  str << ", " << ID_FROM_HANDLE( prev_ent );
399 
400  i = j;
401  if( i == end ) break;
402 
403  str << ',';
404  if( TYPE_FROM_HANDLE( *i ) != prev_type )
405  str << ' ' << CN::EntityTypeName( prev_type = TYPE_FROM_HANDLE( *i ) );
406  str << ' ' << ID_FROM_HANDLE( *i );
407  prev_ent = *i;
408  }
409  str << std::endl;
410 }
411 
412 void print_handle_vect( const char* prefix, const std::vector< EntityHandle >& vect )
413 {
414  print_handles( std::cout, prefix, vect.begin(), vect.end() );
415 }
416 
417 void print_mbrange( const char* prefix, const Range& range )
418 {
419  print_handles( std::cout, prefix, range.begin(), range.end() );
420 }
421 
422 bool compare_set_contents( unsigned flags,
423  const std::vector< EntityHandle >& expected,
424  int set_count,
425  std::vector< EntityHandle >& vect,
426  const Range& range )
427 {
428 
429  std::vector< EntityHandle > sorted( expected );
430  std::sort( sorted.begin(), sorted.end() );
431  sorted.erase( std::unique( sorted.begin(), sorted.end() ), sorted.end() );
432 
433  int expected_size = 0;
434  if( flags & MESHSET_ORDERED )
435  {
436  if( expected != vect )
437  {
438  std::cout << "Incorrect set contents from vector-based query" << std::endl;
439  print_handle_vect( "Expected", expected );
440  print_handle_vect( "Actual", vect );
441  return false;
442  }
443  expected_size = expected.size();
444  }
445  else
446  {
447  if( sorted != vect )
448  {
449  std::cout << "Incorrect set contents from vector-based query" << std::endl;
450  print_handle_vect( "Expected", sorted );
451  print_handle_vect( "Actual", vect );
452  return false;
453  }
454  expected_size = sorted.size();
455  }
456 
457  if( expected_size != set_count )
458  {
459  std::cout << "Incorrect size for entity set" << std::endl;
460  std::cout << "Expected: " << expected_size << std::endl;
461  std::cout << "Actual: " << set_count << std::endl;
462  return false;
463  }
464 
465  vect.clear();
466  vect.resize( range.size() );
467  std::copy( range.begin(), range.end(), vect.begin() );
468  if( sorted != vect )
469  {
470  std::cout << "Incorrect set contents from mbrange-based query" << std::endl;
471  print_handle_vect( "Expected", vect );
472  print_mbrange( "Actual", range );
473  return false;
474  }
475 
476  return true;
477 }
478 
479 bool check_set_contents( Core& mb, EntityHandle set, const std::vector< EntityHandle >& expected )
480 {
481  unsigned flags;
482  ErrorCode rval = mb.get_meshset_options( set, flags );CHECK_ERR( rval );
483 
484  int count;
485  std::vector< EntityHandle > vect;
486  Range range;
487  rval = mb.get_entities_by_handle( set, vect, false );CHECK_ERR( rval );
488  rval = mb.get_entities_by_handle( set, range, false );CHECK_ERR( rval );
489  rval = mb.get_number_entities_by_handle( set, count, false );CHECK_ERR( rval );
490 
491  if( !compare_set_contents( flags, expected, count, vect, range ) ) return false;
492 
493  if( !( flags & MESHSET_TRACK_OWNER ) ) return true;
494 
495  // get all entitites with an adjacency to the set
496  std::vector< EntityHandle > adj;
497  Range all, adjacent;
498  Range::iterator in = adjacent.begin();
499  mb.get_entities_by_handle( 0, all );
500  for( Range::iterator i = all.begin(); i != all.end(); ++i )
501  {
502  adj.clear();
503  rval = mb.a_entity_factory()->get_adjacencies( *i, adj );CHECK_ERR( rval );
504  std::vector< EntityHandle >::iterator j = std::lower_bound( adj.begin(), adj.end(), set );
505  if( j != adj.end() && *j == set ) in = adjacent.insert( in, *i, *i );
506  }
507 
508  if( range != adjacent )
509  {
510  std::cout << "Incorrect adjacent entities for tracking set" << std::endl;
511  print_mbrange( "Expected", range );
512  print_mbrange( "Actual", adjacent );
513  return false;
514  }
515 
516  return true;
517 }
518 
519 bool check_set_contents( Core& mb, EntityType type, EntityHandle set, unsigned flags )
520 {
521  ErrorCode rval;
522  int count;
523  std::vector< EntityHandle > vect, expected;
524  Range range;
525 
526  rval = mb.get_entities_by_handle( set, expected, false );CHECK_ERR( rval );
527  std::vector< EntityHandle >::iterator i = expected.begin();
528  while( i != expected.end() )
529  {
530  if( TYPE_FROM_HANDLE( *i ) != type )
531  i = expected.erase( i );
532  else
533  ++i;
534  }
535 
536  rval = mb.get_entities_by_type( set, type, range, false );CHECK_ERR( rval );
537  rval = mb.get_number_entities_by_type( set, type, count, false );CHECK_ERR( rval );
538 
539  std::copy( range.begin(), range.end(), std::back_inserter( vect ) );
540  return compare_set_contents( flags, expected, count, vect, range );
541 }
542 
543 bool check_set_contents( Core& mb, int dim, EntityHandle set, unsigned flags )
544 {
545  ErrorCode rval;
546  int count;
547  std::vector< EntityHandle > vect, expected;
548  Range range;
549 
550  rval = mb.get_entities_by_handle( set, expected, false );CHECK_ERR( rval );
551  std::vector< EntityHandle >::iterator i = expected.begin();
552  while( i != expected.end() )
553  {
554  if( CN::Dimension( TYPE_FROM_HANDLE( *i ) ) != dim )
555  i = expected.erase( i );
556  else
557  ++i;
558  }
559 
560  rval = mb.get_entities_by_dimension( set, dim, range, false );CHECK_ERR( rval );
561  rval = mb.get_number_entities_by_dimension( set, dim, count, false );CHECK_ERR( rval );
562 
563  std::copy( range.begin(), range.end(), std::back_inserter( vect ) );
564  return compare_set_contents( flags, expected, count, vect, range );
565 }
566 
567 void test_add_entities( unsigned flags )
568 {
569  Core mb;
570  make_mesh( mb );
571 
572  EntityHandle set;
573  ErrorCode rval = mb.create_meshset( flags, set );CHECK_ERR( rval );
574 
575  std::vector< EntityHandle > contents, vect;
576  Range range;
577 
578  range.clear();
579  range.insert( 11, 20 );
580  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
581  rval = mb.add_entities( set, range );CHECK_ERR( rval );
582  // [11,20]
583  CHECK( check_set_contents( mb, set, contents ) );
584 
585  range.clear();
586  range.insert( 31, 40 );
587  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
588  rval = mb.add_entities( set, range );CHECK_ERR( rval );
589  // [11,20],[31,40]
590  CHECK( check_set_contents( mb, set, contents ) );
591 
592  range.clear();
593  range.insert( 51, 60 );
594  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
595  rval = mb.add_entities( set, range );CHECK_ERR( rval );
596  // [11,20],[31,40],[51,60]
597  CHECK( check_set_contents( mb, set, contents ) );
598 
599  range.clear();
600  range.insert( 71, 80 );
601  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
602  rval = mb.add_entities( set, range );CHECK_ERR( rval );
603  // [11,20],[31,40],[51,60],[71,80]
604  CHECK( check_set_contents( mb, set, contents ) );
605 
606  range.clear();
607  range.insert( 91, 100 );
608  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
609  rval = mb.add_entities( set, range );CHECK_ERR( rval );
610  // [11,20],[31,40],[51,60],[71,80],[91,100]
611  CHECK( check_set_contents( mb, set, contents ) );
612 
613  range.clear();
614  range.insert( 111, 120 );
615  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
616  rval = mb.add_entities( set, range );CHECK_ERR( rval );
617  // [11,20],[31,40],[51,60],[71,80],[91,100],[111,120]
618  CHECK( check_set_contents( mb, set, contents ) );
619 
620  range.clear();
621  range.insert( 6, 12 );
622  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
623  rval = mb.add_entities( set, range );CHECK_ERR( rval );
624  // [6,20],[31,40],[51,60],[71,80],[91,100],[111,120]
625  CHECK( check_set_contents( mb, set, contents ) );
626 
627  range.clear();
628  range.insert( 1, 3 );
629  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
630  rval = mb.add_entities( set, range );CHECK_ERR( rval );
631  // [1,3],[6,20],[31,40],[51,60],[71,80],[91,100],[111,120]
632  CHECK( check_set_contents( mb, set, contents ) );
633 
634  range.clear();
635  range.insert( 25, 25 );
636  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
637  rval = mb.add_entities( set, range );CHECK_ERR( rval );
638  // [1,3],[6,20],[25,25],[31,40],[51,60],[71,80],[91,100],[111,120]
639  CHECK( check_set_contents( mb, set, contents ) );
640 
641  range.clear();
642  range.insert( 30, 30 );
643  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
644  rval = mb.add_entities( set, range );CHECK_ERR( rval );
645  // [1,3],[6,20],[25,25],[30,40],[51,60],[71,80],[91,100],[111,120]
646  CHECK( check_set_contents( mb, set, contents ) );
647 
648  range.clear();
649  range.insert( 29, 31 );
650  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
651  rval = mb.add_entities( set, range );CHECK_ERR( rval );
652  // [1,3],[6,20],[25,25],[29,40],[51,60],[71,80],[91,100],[111,120]
653  CHECK( check_set_contents( mb, set, contents ) );
654 
655  range.clear();
656  range.insert( 41, 41 );
657  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
658  rval = mb.add_entities( set, range );CHECK_ERR( rval );
659  // [1,3],[6,20],[25,25],[29,41],[51,60],[71,80],[91,100],[111,120]
660  CHECK( check_set_contents( mb, set, contents ) );
661 
662  range.clear();
663  range.insert( 41, 45 );
664  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
665  rval = mb.add_entities( set, range );CHECK_ERR( rval );
666  // [1,3],[6,20],[25,25],[29,45],[51,60],[71,80],[91,100],[111,120]
667  CHECK( check_set_contents( mb, set, contents ) );
668 
669  range.clear();
670  range.insert( 47, 47 );
671  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
672  rval = mb.add_entities( set, range );CHECK_ERR( rval );
673  // [1,3],[6,20],[25,25],[29,45],[47,47],[51,60],[71,80],[91,100],[111,120]
674  CHECK( check_set_contents( mb, set, contents ) );
675 
676  range.clear();
677  range.insert( 51, 80 );
678  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
679  rval = mb.add_entities( set, range );CHECK_ERR( rval );
680  // [1,3],[6,20],[25,25],[29,45],[47,47],[51,80],[91,100],[111,120]
681  CHECK( check_set_contents( mb, set, contents ) );
682 
683  range.clear();
684  range.insert( 49, 105 );
685  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
686  rval = mb.add_entities( set, range );CHECK_ERR( rval );
687  // [1,3],[6,20],[25,25],[29,45],[47,47],[49,105],[111,120]
688  CHECK( check_set_contents( mb, set, contents ) );
689 
690  vect.clear();
691  for( EntityHandle h = 1; h < 100; ++h )
692  {
693  vect.push_back( h );
694  contents.push_back( h );
695  }
696  rval = mb.add_entities( set, &vect[0], vect.size() );CHECK_ERR( rval );
697  // [1,105],[111,120]
698  CHECK( check_set_contents( mb, set, contents ) );
699 
700  vect.clear();
701  vect.push_back( 106 );
702  vect.push_back( 108 );
703  vect.push_back( 110 );
704  std::copy( vect.begin(), vect.end(), std::back_inserter( contents ) );
705  rval = mb.add_entities( set, &vect[0], vect.size() );CHECK_ERR( rval );
706  // [1,106],[108,108],[110,120]
707  CHECK( check_set_contents( mb, set, contents ) );
708 
709  range.clear();
710  range.insert( 107, 200 );
711  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
712  rval = mb.add_entities( set, range );CHECK_ERR( rval );
713  // [1,200]
714  CHECK( check_set_contents( mb, set, contents ) );
715 
716  range.clear();
717  range.insert( 1, 1 );
718  range.insert( 5, 6 );
719  range.insert( 199, 200 );
720  range.insert( 201, 202 );
721  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
722  rval = mb.add_entities( set, range );CHECK_ERR( rval );
723  // [1,202]
724  CHECK( check_set_contents( mb, set, contents ) );
725 
726  range.clear();
727  range.insert( 300, 301 );
728  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
729  rval = mb.add_entities( set, range );CHECK_ERR( rval );
730  // [1,202],[300,301]
731  CHECK( check_set_contents( mb, set, contents ) );
732 
733  range.clear();
734  range.insert( 203, 203 );
735  range.insert( 205, 205 );
736  range.insert( 207, 207 );
737  range.insert( 299, 299 );
738  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
739  rval = mb.add_entities( set, range );CHECK_ERR( rval );
740  // [1,203],[205,205],[207,207],[299,301]
741  CHECK( check_set_contents( mb, set, contents ) );
742 }
743 
744 void remove_from_back( std::vector< EntityHandle >& vect, const Range& range )
745 {
746  for( Range::const_iterator r = range.begin(); r != range.end(); ++r )
747  {
748  std::vector< EntityHandle >::reverse_iterator i = find( vect.rbegin(), vect.rend(), *r );
749  if( i != vect.rend() ) *i = 0;
750  }
751  std::vector< EntityHandle >::iterator j = vect.begin();
752  while( j != vect.end() )
753  {
754  if( *j == 0 )
755  j = vect.erase( j );
756  else
757  ++j;
758  }
759 }
760 
761 void test_remove_entities( unsigned flags )
762 {
763  Core mb;
764  make_mesh( mb );
765 
766  EntityHandle set;
767  ErrorCode rval = mb.create_meshset( flags, set );CHECK_ERR( rval );
768 
769  std::vector< EntityHandle > contents;
770  Range range;
771 
772  range.clear();
773  range.insert( 1, 1000 );
774  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
775  rval = mb.add_entities( set, range );CHECK_ERR( rval );
776  // [1,1000]
777  CHECK( check_set_contents( mb, set, contents ) );
778 
779  range.clear();
780  range.insert( 1, 5 );
781  remove_from_back( contents, range );
782  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
783  // [6,1000]
784  CHECK( check_set_contents( mb, set, contents ) );
785 
786  range.clear();
787  range.insert( 6, 6 );
788  remove_from_back( contents, range );
789  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
790  // [7,1000]
791  CHECK( check_set_contents( mb, set, contents ) );
792 
793  range.clear();
794  range.insert( 7, 10 );
795  remove_from_back( contents, range );
796  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
797  // [11,1000]
798  CHECK( check_set_contents( mb, set, contents ) );
799 
800  range.clear();
801  range.insert( 1, 20 );
802  remove_from_back( contents, range );
803  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
804  // [21,1000]
805  CHECK( check_set_contents( mb, set, contents ) );
806 
807  range.clear();
808  range.insert( 1, 5 );
809  remove_from_back( contents, range );
810  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
811  // [21,1000]
812  CHECK( check_set_contents( mb, set, contents ) );
813 
814  range.clear();
815  range.insert( 22, 30 );
816  remove_from_back( contents, range );
817  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
818  // [21,21],[31,1000]
819  CHECK( check_set_contents( mb, set, contents ) );
820 
821  range.clear();
822  range.insert( 1000, 1000 );
823  remove_from_back( contents, range );
824  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
825  // [21,21],[31,999]
826  CHECK( check_set_contents( mb, set, contents ) );
827 
828  range.clear();
829  range.insert( 901, 999 );
830  remove_from_back( contents, range );
831  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
832  // [21,21],[31,900]
833  CHECK( check_set_contents( mb, set, contents ) );
834 
835  range.clear();
836  range.insert( 900, 999 );
837  remove_from_back( contents, range );
838  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
839  // [21,21],[31,899]
840  CHECK( check_set_contents( mb, set, contents ) );
841 
842  range.clear();
843  range.insert( 1000, 1001 );
844  remove_from_back( contents, range );
845  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
846  // [21,21],[31,899]
847  CHECK( check_set_contents( mb, set, contents ) );
848 
849  range.clear();
850  range.insert( 890, 898 );
851  remove_from_back( contents, range );
852  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
853  // [21,21],[31,889],[899,899]
854  CHECK( check_set_contents( mb, set, contents ) );
855 
856  range.clear();
857  range.insert( 100, 149 );
858  remove_from_back( contents, range );
859  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
860  // [21,21],[31,99],[150,889],[899,899]
861  CHECK( check_set_contents( mb, set, contents ) );
862 
863  range.clear();
864  range.insert( 31, 99 );
865  remove_from_back( contents, range );
866  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
867  // [21,21],[150,889],[899,899]
868  CHECK( check_set_contents( mb, set, contents ) );
869 
870  range.clear();
871  range.insert( 200, 249 );
872  remove_from_back( contents, range );
873  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
874  // [21,21],[150,199],[250,889],[899,899]
875  CHECK( check_set_contents( mb, set, contents ) );
876 
877  range.clear();
878  range.insert( 300, 349 );
879  remove_from_back( contents, range );
880  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
881  // [21,21],[150,199],[250,299],[350,889],[899,899]
882  CHECK( check_set_contents( mb, set, contents ) );
883 
884  range.clear();
885  range.insert( 159, 399 );
886  remove_from_back( contents, range );
887  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
888  // [21,21],[150,158],[400,889],[899,899]
889  CHECK( check_set_contents( mb, set, contents ) );
890 
891  range.clear();
892  range.insert( 450, 499 );
893  remove_from_back( contents, range );
894  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
895  // [21,21],[150,158],[400,449],[500,889],[899,899]
896  CHECK( check_set_contents( mb, set, contents ) );
897 
898  range.clear();
899  range.insert( 550, 599 );
900  remove_from_back( contents, range );
901  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
902  // [21,21],[150,158],[400,449],[500,549],[600,889],[899,899]
903  CHECK( check_set_contents( mb, set, contents ) );
904 
905  range.clear();
906  range.insert( 150, 549 );
907  remove_from_back( contents, range );
908  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
909  // [21,21],[600,889],[899,899]
910  CHECK( check_set_contents( mb, set, contents ) );
911 
912  range.clear();
913  range.insert( 650, 699 );
914  remove_from_back( contents, range );
915  rval = mb.remove_entities( set, range );CHECK_ERR( rval );
916  // [21,21],[600,649],[700,889],[899,899]
917  CHECK( check_set_contents( mb, set, contents ) );
918 
919  // test vector-based remove
920  assert( contents.size() == 242 );
921  std::vector< EntityHandle > remlist( 5 );
922  remlist[0] = contents[240];
923  contents.erase( contents.begin() + 240 );
924  remlist[1] = contents[200];
925  contents.erase( contents.begin() + 200 );
926  remlist[2] = contents[100];
927  contents.erase( contents.begin() + 100 );
928  remlist[3] = contents[25];
929  contents.erase( contents.begin() + 25 );
930  remlist[4] = contents[0];
931  contents.erase( contents.begin() + 0 );
932  rval = mb.remove_entities( set, &remlist[0], remlist.size() );CHECK_ERR( rval );
933  // [600,623],[625,649],[700,748],[750,848],[850,888],[899,899]
934  CHECK( check_set_contents( mb, set, contents ) );
935 
936  // remove everything
937  std::reverse( contents.begin(), contents.begin() + contents.size() / 2 ); // mix up a bit
938  rval = mb.remove_entities( set, &contents[0], contents.size() );CHECK_ERR( rval );
939  contents.clear();
940  CHECK( check_set_contents( mb, set, contents ) );
941 
942  // try complicated range-based remove
943  range.clear();
944  contents.clear();
945  range.insert( 100, 200 );
946  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
947  rval = mb.add_entities( set, range );CHECK_ERR( rval );
948  // [1000,2000]
949  CHECK( check_set_contents( mb, set, contents ) );
950 
951  Range remove;
952  remove.insert( 1, 3 );
953  remove.insert( 10, 100 );
954  remove.insert( 110, 120 );
955  remove.insert( 130, 140 );
956  remove.insert( 150, 160 );
957  remove.insert( 190, 200 );
958  remove.insert( 210, 220 );
959  remove.insert( 230, 240 );
960  range = subtract( range, remove );
961 
962  contents.clear();
963  std::copy( range.begin(), range.end(), std::back_inserter( contents ) );
964  rval = mb.remove_entities( set, remove );CHECK_ERR( rval );
965  CHECK( check_set_contents( mb, set, contents ) );
966 }
967 
968 void test_entities_by_type( unsigned flags )
969 {
970  EntityHandle first_vert, last_vert, first_hex, last_hex;
971  Core mb;
972  make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
973 
974  // Create an entity set
975  EntityHandle set;
976  ErrorCode rval = mb.create_meshset( flags, set );CHECK_ERR( rval );
977 
978  // Test empty set
979  CHECK( check_set_contents( mb, MBVERTEX, set, flags ) );
980  CHECK( check_set_contents( mb, MBEDGE, set, flags ) );
981  CHECK( check_set_contents( mb, MBHEX, set, flags ) );
982 
983  // Add stuff to set
984  Range range;
985  range.insert( first_vert, first_vert + 10 );
986  range.insert( first_vert + 100, first_vert + 110 );
987  range.insert( first_hex + 200, first_hex + 299 );
988  range.insert( last_hex, last_hex - 99 );
989  rval = mb.add_entities( set, range );CHECK_ERR( rval );
990 
991  // Test
992  CHECK( check_set_contents( mb, MBVERTEX, set, flags ) );
993  CHECK( check_set_contents( mb, MBEDGE, set, flags ) );
994  CHECK( check_set_contents( mb, MBHEX, set, flags ) );
995 }
996 
997 void test_entities_by_dimension( unsigned flags )
998 {
999  EntityHandle first_vert, last_vert, first_hex, last_hex;
1000  Core mb;
1001  make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
1002 
1003  // Create an entity set
1004  EntityHandle set;
1005  ErrorCode rval = mb.create_meshset( flags, set );CHECK_ERR( rval );
1006 
1007  // Test empty set
1008  CHECK( check_set_contents( mb, 0, set, flags ) );
1009  CHECK( check_set_contents( mb, 1, set, flags ) );
1010  CHECK( check_set_contents( mb, 2, set, flags ) );
1011  CHECK( check_set_contents( mb, 3, set, flags ) );
1012 
1013  // Add stuff to set
1014  Range range;
1015  range.insert( first_vert, first_vert + 10 );
1016  range.insert( first_vert + 100, first_vert + 110 );
1017  range.insert( first_hex + 200, first_hex + 299 );
1018  range.insert( last_hex, last_hex - 99 );
1019  rval = mb.add_entities( set, range );CHECK_ERR( rval );
1020 
1021  // Test
1022  CHECK( check_set_contents( mb, 0, set, flags ) );
1023  CHECK( check_set_contents( mb, 1, set, flags ) );
1024  CHECK( check_set_contents( mb, 2, set, flags ) );
1025  CHECK( check_set_contents( mb, 3, set, flags ) );
1026 }
1027 
1028 bool test_boolean( Core& mb,
1029  BoolOp op,
1030  unsigned flags1,
1031  const Range& set1_ents,
1032  unsigned flags2,
1033  const Range& set2_ents )
1034 {
1035  ErrorCode rval;
1036 
1037  // make sets
1038  EntityHandle set1, set2;
1039  rval = mb.create_meshset( flags1, set1 );CHECK_ERR( rval );
1040  rval = mb.create_meshset( flags2, set2 );CHECK_ERR( rval );
1041  rval = mb.add_entities( set1, set1_ents );CHECK_ERR( rval );
1042  rval = mb.add_entities( set2, set2_ents );CHECK_ERR( rval );
1043 
1044  Range tmp_range;
1045  std::vector< EntityHandle > expected;
1046  rval = MB_INDEX_OUT_OF_RANGE;
1047  switch( op )
1048  {
1049  case UNITE:
1050  if( flags1 & MESHSET_SET )
1051  {
1052  tmp_range = set1_ents;
1053  tmp_range.merge( set2_ents );
1054  expected.resize( tmp_range.size() );
1055  std::copy( tmp_range.begin(), tmp_range.end(), expected.begin() );
1056  }
1057  else
1058  {
1059  expected.clear();
1060  std::copy( set1_ents.begin(), set1_ents.end(), std::back_inserter( expected ) );
1061  std::copy( set2_ents.begin(), set2_ents.end(), std::back_inserter( expected ) );
1062  }
1063  rval = mb.unite_meshset( set1, set2 );
1064  break;
1065  case INTERSECT:
1066  tmp_range = intersect( set1_ents, set2_ents );
1067  expected.resize( tmp_range.size() );
1068  std::copy( tmp_range.begin(), tmp_range.end(), expected.begin() );
1069  rval = mb.intersect_meshset( set1, set2 );
1070  break;
1071  case SUBTRACT:
1072  tmp_range = subtract( set1_ents, set2_ents );
1073  expected.resize( tmp_range.size() );
1074  std::copy( tmp_range.begin(), tmp_range.end(), expected.begin() );
1075  rval = mb.subtract_meshset( set1, set2 );
1076  break;
1077  }
1078  CHECK_ERR( rval );
1079 
1080  return check_set_contents( mb, set1, expected );
1081 }
1082 
1083 void test_intersect( unsigned flags1, unsigned flags2 )
1084 {
1085  Range empty, set1_ents, set2_ents;
1086  EntityHandle first_vert, last_vert, first_hex, last_hex;
1087  Core mb;
1088  make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
1089 
1090  // define contents of first set
1091  set1_ents.insert( first_vert, first_vert + 10 );
1092  set1_ents.insert( first_vert + 100, first_vert + 199 );
1093  set1_ents.insert( first_hex + 100, first_hex + 200 );
1094 
1095  // define contents of second set
1096  set2_ents.insert( first_vert, first_vert );
1097  set2_ents.insert( first_vert + 10, first_vert + 10 );
1098  set2_ents.insert( first_vert + 90, first_vert + 209 );
1099  set2_ents.insert( first_hex + 50, first_hex + 300 );
1100 
1101  // check empty sets
1102  CHECK( test_boolean( mb, INTERSECT, flags1, empty, flags2, empty ) );
1103  // check intersection with 1 empty
1104  CHECK( test_boolean( mb, INTERSECT, flags1, empty, flags2, set2_ents ) );
1105  CHECK( test_boolean( mb, INTERSECT, flags1, set1_ents, flags2, empty ) );
1106  // check intersection of non-empty sets
1107  CHECK( test_boolean( mb, INTERSECT, flags1, set1_ents, flags2, set2_ents ) );
1108 }
1109 
1110 void test_unite( unsigned flags1, unsigned flags2 )
1111 {
1112  Range empty, set1_ents, set2_ents;
1113  EntityHandle first_vert, last_vert, first_hex, last_hex;
1114  Core mb;
1115  make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
1116 
1117  // define contents of first set
1118  set1_ents.insert( first_vert, first_vert + 10 );
1119  set1_ents.insert( first_vert + 100, first_vert + 199 );
1120  set1_ents.insert( first_hex + 100, first_hex + 200 );
1121 
1122  // define contents of second set
1123  set2_ents.insert( first_vert, first_vert );
1124  set2_ents.insert( first_vert + 11, first_vert + 99 );
1125  set2_ents.insert( first_vert + 150, first_vert + 209 );
1126  set2_ents.insert( first_vert + 211, first_vert + 211 );
1127  set2_ents.insert( first_hex + 50, first_hex + 99 );
1128 
1129  // check empty sets
1130  CHECK( test_boolean( mb, UNITE, flags1, empty, flags2, empty ) );
1131  // check union with 1 empty
1132  CHECK( test_boolean( mb, UNITE, flags1, empty, flags2, set2_ents ) );
1133  CHECK( test_boolean( mb, UNITE, flags1, set1_ents, flags2, empty ) );
1134  // check union of non-empty sets
1135  CHECK( test_boolean( mb, UNITE, flags1, set1_ents, flags2, set2_ents ) );
1136 }
1137 
1138 void test_subtract( unsigned flags1, unsigned flags2 )
1139 {
1140  Range empty, set1_ents, set2_ents;
1141  EntityHandle first_vert, last_vert, first_hex, last_hex;
1142  Core mb;
1143  make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
1144 
1145  // define contents of first set
1146  set1_ents.insert( first_vert, first_vert + 10 );
1147  set1_ents.insert( first_vert + 100, first_vert + 199 );
1148  set1_ents.insert( first_hex + 100, first_hex + 200 );
1149 
1150  // define contents of second set
1151  set2_ents.insert( first_vert, first_vert );
1152  set2_ents.insert( first_vert + 9, first_vert + 9 );
1153  set2_ents.insert( first_vert + 11, first_vert + 99 );
1154  set2_ents.insert( first_vert + 150, first_vert + 199 );
1155  set2_ents.insert( first_hex + 50, first_hex + 60 );
1156  set2_ents.insert( first_hex + 90, first_hex + 220 );
1157 
1158  // check empty sets
1159  CHECK( test_boolean( mb, SUBTRACT, flags1, empty, flags2, empty ) );
1160  // check union with 1 empty
1161  CHECK( test_boolean( mb, SUBTRACT, flags1, empty, flags2, set2_ents ) );
1162  CHECK( test_boolean( mb, SUBTRACT, flags1, set1_ents, flags2, empty ) );
1163  // check union of non-empty sets
1164  CHECK( test_boolean( mb, SUBTRACT, flags1, set1_ents, flags2, set2_ents ) );
1165 }
1166 
1167 void test_contains_entities( unsigned flags )
1168 {
1169  CHECK( !( flags & MESHSET_TRACK_OWNER ) );
1170  MeshSet set( flags );
1171  bool result;
1172 
1173  const EntityHandle entities[] = { 1, 2, 3, 6, 10, 11, 25, 100 };
1174  const int num_ents = sizeof( entities ) / sizeof( EntityHandle );
1175  ErrorCode rval = set.add_entities( entities, num_ents, 0, 0 );CHECK_ERR( rval );
1176 
1177  result = set.contains_entities( entities, num_ents, Interface::UNION );
1178  CHECK( result );
1179  result = set.contains_entities( entities, num_ents, Interface::INTERSECT );
1180  CHECK( result );
1181 
1182  result = set.contains_entities( entities, 1, Interface::UNION );
1183  CHECK( result );
1184  result = set.contains_entities( entities, 1, Interface::INTERSECT );
1185  CHECK( result );
1186 
1187  const EntityHandle entities2[] = { 3, 4, 5 };
1188  const int num_ents2 = sizeof( entities2 ) / sizeof( EntityHandle );
1189  result = set.contains_entities( entities2, num_ents2, Interface::UNION );
1190  CHECK( result );
1191  result = set.contains_entities( entities2, num_ents2, Interface::INTERSECT );
1192  CHECK( !result );
1193 }
1194 
1195 void test_clear( unsigned flags )
1196 {
1197  std::vector< EntityHandle > contents( 4 );
1198  Core mb;
1199  make_mesh( mb, contents[0], contents[1], contents[2], contents[3] );
1200  EntityHandle set;
1201  ErrorCode rval = mb.create_meshset( flags, set );CHECK_ERR( rval );
1202  rval = mb.add_entities( set, &contents[0], contents.size() );CHECK_ERR( rval );
1203  CHECK( check_set_contents( mb, set, contents ) );
1204  rval = mb.clear_meshset( &set, 1 );CHECK_ERR( rval );
1205  contents.clear();
1206  CHECK( check_set_contents( mb, set, contents ) );
1207 }
1208 
1209 void regression_insert_set_1()
1210 {
1211  EntityHandle e = CREATE_HANDLE( MBEDGE, 0 );
1212  EntityHandle q = CREATE_HANDLE( MBQUAD, 0 );
1213  const EntityHandle initial_ranges[] = {
1214  0x7fe, 0x7fe, 0x802, 0x80b, 0xb3a, 0xb3c, 0xb6b, 0xb6b, 0xbed,
1215  0xbee, 0x19ff, 0x19ff, 0x1a0b, 0x1a0b, 0x1a16, 0x1a17, 0x1a56, 0x1a57,
1216  0x2554, 0x255c, e + 0x0099, e + 0x009b, e + 0x00c0, e + 0x00c2, e + 0x0729, e + 0x0732, e + 0x0a3b,
1217  e + 0x0a3d, e + 0x0ba9, e + 0x0bab, e + 0x2322, e + 0x232b, q + 0x00c, q + 0x017, q + 0x0e9, q + 0x112,
1218  q + 0x2f2, q + 0x303, q + 0x67e, q + 0x6a5, q + 0x866, q + 0x871, q + 0x8f5, q + 0x900, q + 0xc06,
1219  q + 0xc17, q + 0xc7e, q + 0xc9b, q + 0xce0, q + 0xd07 };
1220 
1221  const EntityHandle new_ranges[] = { 0x7e1, 0x829, 0xb37, 0xb63, 0xb6b, 0xb6b, 0xb73, 0xb75, 0xbed,
1222  0xbee, 0xc0b, 0xc10, 0x19fd, 0x19fd, 0x19ff, 0x19ff, 0x1a02, 0x1a04,
1223  0x1a0b, 0x1a0b, 0x1a11, 0x1a17, 0x1a1b, 0x1a23, 0x1a56, 0x1a57, 0x1a7c,
1224  0x1a96, 0x1bb5, 0x1bba, 0x254b, 0x2565, 0x25a5, 0x25bf };
1225 
1226  Core moab;
1227  Interface& mb = moab;
1228  ErrorCode rval;
1229 
1230  EntityHandle set;
1231  rval = mb.create_meshset( MESHSET_SET, set );CHECK_ERR( rval );
1232 
1233  Range init, add;
1234  for( size_t i = 0; i < sizeof( initial_ranges ) / sizeof( initial_ranges[0] ); i += 2 )
1235  init.insert( initial_ranges[i], initial_ranges[i + 1] );
1236  for( size_t i = 0; i < sizeof( new_ranges ) / sizeof( new_ranges[0] ); i += 2 )
1237  add.insert( new_ranges[i], new_ranges[i + 1] );
1238 
1239  rval = mb.add_entities( set, init );CHECK_ERR( rval );
1240  rval = mb.add_entities( set, add );CHECK_ERR( rval );
1241 
1242  std::vector< EntityHandle > contents;
1243  rval = mb.get_entities_by_handle( set, contents );CHECK_ERR( rval );
1244 
1245  init.merge( add );
1246  Range::iterator r = init.begin();
1247  std::vector< EntityHandle >::iterator v = contents.begin();
1248  for( ;; )
1249  {
1250  if( r == init.end() || v == contents.end() )
1251  {
1252  CHECK( r == init.end() );
1253  CHECK( v == contents.end() );
1254  break;
1255  }
1256  CHECK_EQUAL( *r, *v );
1257  ++r;
1258  ++v;
1259  }
1260 }
1261 
1262 void test_all_iterators()
1263 {
1264  test_iterators( MESHSET_SET, true, false );
1265  test_iterators( MESHSET_SET, false, true );
1266 
1267  test_iterators( MESHSET_ORDERED, true, false );
1268  test_iterators( MESHSET_ORDERED, false, true );
1269 }
1270 
1271 void test_iterators( unsigned int flags, bool test_type, bool test_dim )
1272 {
1273  if( test_type && test_dim ) CHECK_ERR( MB_FAILURE );
1274 
1275  EntityHandle first_vert, last_vert, first_hex, last_hex;
1276  Core mb;
1277  make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
1278 
1279  // Create an entity set
1280  EntityHandle set;
1281  ErrorCode rval = mb.create_meshset( flags, set );CHECK_ERR( rval );
1282 
1283  // Test iteration over empty set
1284  SetIterator* iter = NULL;
1285  rval = mb.create_set_iterator( set, MBMAXTYPE, -1, 1, false, iter );CHECK_ERR( rval );
1286  if( NULL != iter )
1287  {
1288  test_iterator( mb, iter, set, MBMAXTYPE, -1 );
1289  delete iter;
1290  iter = NULL;
1291  }
1292 
1293  rval = mb.create_set_iterator( set, MBMAXTYPE, -1, 100, false, iter );CHECK_ERR( rval );
1294  if( NULL != iter )
1295  {
1296  test_iterator( mb, iter, set, MBMAXTYPE, -1 );
1297  delete iter;
1298  iter = NULL;
1299  }
1300 
1301  rval = mb.create_set_iterator( set, MBMAXTYPE, 0, 1, false, iter );CHECK_ERR( rval );
1302  if( NULL != iter )
1303  {
1304  test_iterator( mb, iter, set, MBMAXTYPE, 0 );
1305  delete iter;
1306  iter = NULL;
1307  }
1308 
1309  rval = mb.create_set_iterator( set, MBMAXTYPE, 3, 1, false, iter );CHECK_ERR( rval );
1310  if( NULL != iter )
1311  {
1312  test_iterator( mb, iter, set, MBMAXTYPE, 3 );
1313  delete iter;
1314  iter = NULL;
1315  }
1316 
1317  // Add stuff to set
1318  Range range;
1319  range.insert( first_vert, first_vert + 10 );
1320  range.insert( first_vert + 100, first_vert + 110 );
1321  range.insert( first_hex + 200, first_hex + 299 );
1322  range.insert( last_hex, last_hex - 99 );
1323  rval = mb.add_entities( set, range );CHECK_ERR( rval );
1324 
1325  EntityType etype = MBVERTEX;
1326  int edim = -1;
1327  if( test_dim && !test_type )
1328  {
1329  edim = 0;
1330  etype = MBMAXTYPE;
1331  }
1332 
1333  // Test
1334  // chunk size 1
1335  rval = mb.create_set_iterator( set, etype, edim, 1, false, iter );CHECK_ERR( rval );
1336  if( NULL != iter )
1337  {
1338  test_iterator( mb, iter, set, etype, edim );
1339  delete iter;
1340  iter = NULL;
1341  }
1342 
1343  // chunk size 3
1344  rval = mb.create_set_iterator( set, etype, edim, 3, false, iter );CHECK_ERR( rval );
1345  if( NULL != iter )
1346  {
1347  test_iterator( mb, iter, set, etype, edim );
1348  delete iter;
1349  iter = NULL;
1350  }
1351 
1352  // chunk size 11
1353  rval = mb.create_set_iterator( set, etype, edim, 11, false, iter );CHECK_ERR( rval );
1354  if( NULL != iter )
1355  {
1356  test_iterator( mb, iter, set, etype, edim );
1357  delete iter;
1358  iter = NULL;
1359  }
1360 
1361  // chunk size 100
1362  rval = mb.create_set_iterator( set, etype, edim, 100, false, iter );CHECK_ERR( rval );
1363  if( NULL != iter )
1364  {
1365  test_iterator( mb, iter, set, etype, edim );
1366  delete iter;
1367  iter = NULL;
1368  }
1369 
1370  if( test_type )
1371  {
1372  // chunk size 1, all ents
1373  rval = mb.create_set_iterator( set, MBMAXTYPE, -1, 1, false, iter );CHECK_ERR( rval );
1374  if( NULL != iter )
1375  {
1376  test_iterator( mb, iter, set, MBMAXTYPE, -1 );
1377  delete iter;
1378  iter = NULL;
1379  }
1380 
1381  // chunk size 3, all ents
1382  rval = mb.create_set_iterator( set, MBMAXTYPE, -1, 3, false, iter );CHECK_ERR( rval );
1383  if( NULL != iter )
1384  {
1385  test_iterator( mb, iter, set, MBMAXTYPE, -1 );
1386  delete iter;
1387  iter = NULL;
1388  }
1389 
1390  // chunk size large, all ents
1391  rval = mb.create_set_iterator( set, MBMAXTYPE, -1, 100000, false, iter );CHECK_ERR( rval );
1392  if( NULL != iter )
1393  {
1394  test_iterator( mb, iter, set, MBMAXTYPE, -1 );
1395  delete iter;
1396  iter = NULL;
1397  }
1398 
1399  etype = MBEDGE;
1400  // edges, chunk size 1
1401  rval = mb.create_set_iterator( set, etype, edim, 1, false, iter );CHECK_ERR( rval );
1402  if( NULL != iter )
1403  {
1404  test_iterator( mb, iter, set, etype, edim );
1405  delete iter;
1406  iter = NULL;
1407  }
1408 
1409  // edges, chunk size 100
1410  rval = mb.create_set_iterator( set, etype, edim, 100, false, iter );CHECK_ERR( rval );
1411  if( NULL != iter )
1412  {
1413  test_iterator( mb, iter, set, etype, edim );
1414  delete iter;
1415  iter = NULL;
1416  }
1417 
1418  etype = MBHEX;
1419 
1420  // hexes, chunk size 1
1421  rval = mb.create_set_iterator( set, etype, edim, 1, false, iter );CHECK_ERR( rval );
1422  if( NULL != iter )
1423  {
1424  test_iterator( mb, iter, set, etype, edim );
1425  delete iter;
1426  iter = NULL;
1427  }
1428 
1429  // hexes, chunk size 3
1430  rval = mb.create_set_iterator( set, etype, edim, 3, false, iter );CHECK_ERR( rval );
1431  if( NULL != iter )
1432  {
1433  test_iterator( mb, iter, set, etype, edim );
1434  delete iter;
1435  iter = NULL;
1436  }
1437 
1438  // hexes, chunk size 1000
1439  rval = mb.create_set_iterator( set, etype, edim, 1000, false, iter );CHECK_ERR( rval );
1440  if( NULL != iter )
1441  {
1442  test_iterator( mb, iter, set, etype, edim );
1443  delete iter;
1444  iter = NULL;
1445  }
1446  }
1447 }
1448 
1449 void test_iterator( Interface& moab, SetIterator* iter, EntityHandle set, EntityType etype, int dim )
1450 {
1451  // iterate over the set, adding to contents
1452  std::vector< EntityHandle > entities, entities2;
1453  bool atend = false;
1454  ErrorCode rval;
1455 
1456  while( !atend )
1457  {
1458  rval = iter->get_next_arr( entities, atend );CHECK_ERR( rval );
1459  }
1460 
1461  // check contents against what's in the set
1462  if( MBMAXTYPE != etype )
1463  {
1464  rval = moab.get_entities_by_type( set, etype, entities2 );CHECK_ERR( rval );
1465  }
1466  else if( MBMAXTYPE == etype && -1 == dim )
1467  {
1468  rval = moab.get_entities_by_handle( set, entities2 );CHECK_ERR( rval );
1469  }
1470  else if( -1 != dim )
1471  {
1472  rval = moab.get_entities_by_dimension( set, dim, entities2 );CHECK_ERR( rval );
1473  }
1474  else
1475  {
1476  // error, one of those needs to be true
1477  CHECK_ERR( MB_FAILURE );
1478  }
1479 
1480  CHECK_EQUAL( entities.size(), entities2.size() );
1481 }