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