MOAB: Mesh Oriented datABase  (version 5.5.0)
Functions | Variables
range_test.cpp File Reference
#include "moab/Range.hpp"
#include "TestUtil.hpp"
+ Include dependency graph for range_test.cpp:

Go to the source code of this file.

Functions

void insert_hint_test ()
 
void intersect_test ()
 
void merge_test ()
 
void const_pair_iterator_test ()
 
void swap_test ()
 
void subtract_test ()
 
void subset_by_dimension_test ()
 
void erase_test ()
 
void contains_test ()
 
int main ()
 

Variables

const EntityHandle h1 = CREATE_HANDLE( MBVERTEX, 1 )
 
const EntityHandle h4 = CREATE_HANDLE( MBVERTEX, 4 )
 
const EntityHandle h5 = CREATE_HANDLE( MBVERTEX, 5 )
 
const EntityHandle h9 = CREATE_HANDLE( MBVERTEX, 9 )
 
const EntityHandle h10 = CREATE_HANDLE( MBVERTEX, 10 )
 
const EntityHandle h15 = CREATE_HANDLE( MBVERTEX, 15 )
 
const EntityHandle h16 = CREATE_HANDLE( MBVERTEX, 16 )
 
const EntityHandle h20 = CREATE_HANDLE( MBVERTEX, 20 )
 
const EntityHandle hh1 = CREATE_HANDLE( MBHEX, 1 )
 
const EntityHandle hh3 = CREATE_HANDLE( MBHEX, 3 )
 

Function Documentation

◆ const_pair_iterator_test()

void const_pair_iterator_test ( )

Definition at line 157 of file range_test.cpp.

158 {
159  // const_pair_iterator test
160  Range r1;
161  r1.insert( h1 );
162  r1.insert( h4 );
163  r1.insert( h5 );
164  Range::const_pair_iterator pair_iter = r1.const_pair_begin();
165  EntityHandle cpi_h1 = ( *pair_iter ).first;
166  EntityHandle cpi_h2 = ( *pair_iter ).second;
167  ++pair_iter;
168  EntityHandle cpi_h3 = ( *pair_iter ).first;
169  EntityHandle cpi_h4 = ( *pair_iter ).second;
170 
171  ++pair_iter;
172  CHECK_EQUAL( cpi_h1, h1 );
173  CHECK_EQUAL( cpi_h2, h1 );
174  CHECK_EQUAL( cpi_h3, h4 );
175  CHECK_EQUAL( cpi_h4, h5 );
176 }

References CHECK_EQUAL, moab::Range::const_pair_begin(), h1, h4, h5, and moab::Range::insert().

Referenced by main().

◆ contains_test()

void contains_test ( )

Definition at line 438 of file range_test.cpp.

439 {
440  Range r1, r2;
441 
442  // simple test cases: one range each
443 
444  r1.clear();
445  r2.clear();
446  r1.insert( 1, 20 );
447  r2.insert( 1, 21 );
448  CHECK( !r1.contains( r2 ) );
449  CHECK( r2.contains( r1 ) );
450 
451  r1.clear();
452  r2.clear();
453  r1.insert( 2, 20 );
454  r2.insert( 1, 20 );
455  CHECK( !r1.contains( r2 ) );
456  CHECK( r2.contains( r1 ) );
457 
458  r1.clear();
459  r2.clear();
460  r1.insert( 5 );
461  r2.insert( 1, 6 );
462  CHECK( !r1.contains( r2 ) );
463  CHECK( r2.contains( r1 ) );
464 
465  r1.clear();
466  r2.clear();
467  r1.insert( 5 );
468  r2.insert( 6 );
469  CHECK( !r1.contains( r2 ) );
470  CHECK( !r2.contains( r1 ) );
471 
472  r1.clear();
473  r2.clear();
474  r1.insert( 18 );
475  r2.insert( 18 );
476  CHECK( r1.contains( r2 ) );
477  CHECK( r2.contains( r1 ) );
478 
479  // empty range test cases
480 
481  r1.clear();
482  r2.clear();
483  CHECK( r1.contains( r2 ) );
484  CHECK( r2.contains( r1 ) );
485 
486  r1.clear();
487  r2.clear();
488  r1.insert( 18 );
489  CHECK( r1.contains( r2 ) );
490  CHECK( !r2.contains( r1 ) );
491 
492  // slightly more complex tests: one range in one container
493  // and multiple in the other
494 
495  r1.clear();
496  r1.insert( 10, 100 );
497  r2.clear();
498  r2.insert( 20, 30 );
499  r2.insert( 40, 50 );
500  CHECK( r1.contains( r2 ) );
501  CHECK( !r2.contains( r1 ) );
502 
503  r2.insert( 10, 12 );
504  CHECK( r1.contains( r2 ) );
505  CHECK( !r2.contains( r1 ) );
506 
507  r2.insert( 90, 100 );
508  CHECK( r1.contains( r2 ) );
509  CHECK( !r2.contains( r1 ) );
510 
511  r2.insert( 9 );
512  CHECK( !r1.contains( r2 ) );
513  CHECK( !r2.contains( r1 ) );
514 
515  r2.erase( 9 );
516  r2.insert( 101 );
517  CHECK( !r1.contains( r2 ) );
518  CHECK( !r2.contains( r1 ) );
519 
520  r2.erase( 101 );
521  r2.insert( 103, 110 );
522  CHECK( !r1.contains( r2 ) );
523  CHECK( !r2.contains( r1 ) );
524 
525  r2.insert( 1, 5 );
526  CHECK( !r1.contains( r2 ) );
527  CHECK( !r2.contains( r1 ) );
528 
529  // most complex case: both containers have several ranges
530 
531  r1.clear();
532  r1.insert( 10, 30 );
533  r1.insert( 40, 50 );
534  r1.insert( 90, 100 );
535  r2.clear();
536  r2.insert( 20, 30 );
537  r2.insert( 40, 50 );
538  CHECK( r1.contains( r2 ) );
539  CHECK( !r2.contains( r1 ) );
540 
541  r2.insert( 10, 12 );
542  CHECK( r1.contains( r2 ) );
543  CHECK( !r2.contains( r1 ) );
544 
545  r2.insert( 90, 100 );
546  CHECK( r1.contains( r2 ) );
547  CHECK( !r2.contains( r1 ) );
548 
549  r2.insert( 9 );
550  CHECK( !r1.contains( r2 ) );
551  CHECK( !r2.contains( r1 ) );
552 
553  r2.erase( 9 );
554  r2.insert( 101 );
555  CHECK( !r1.contains( r2 ) );
556  CHECK( !r2.contains( r1 ) );
557 
558  r2.erase( 101 );
559  r2.insert( 103, 110 );
560  CHECK( !r1.contains( r2 ) );
561  CHECK( !r2.contains( r1 ) );
562 
563  r2.insert( 1, 5 );
564  CHECK( !r1.contains( r2 ) );
565  CHECK( !r2.contains( r1 ) );
566 }

References CHECK, moab::Range::clear(), moab::Range::contains(), moab::Range::erase(), and moab::Range::insert().

Referenced by main().

◆ erase_test()

void erase_test ( )

Definition at line 275 of file range_test.cpp.

276 {
277  Range range;
278  Range::iterator result;
279 
280  // test erase from first node
281  range.clear();
282  range.insert( 5, 10 );
283  range.insert( 12, 20 );
284  result = range.erase( range.begin(), range.begin() + 2 );
285  CHECK_EQUAL( (EntityHandle)7, range.front() );
286  CHECK_EQUAL( (EntityHandle)20, range.back() );
287  CHECK_EQUAL( (size_t)13, range.size() );
288  CHECK_EQUAL( (EntityHandle)7, *result );
289 
290  // test erase first node
291  range.clear();
292  range.insert( 5, 10 );
293  range.insert( 12, 20 );
294  result = range.erase( range.begin(), range.begin() + 6 );
295  CHECK_EQUAL( (EntityHandle)12, range.front() );
296  CHECK_EQUAL( (EntityHandle)20, range.back() );
297  CHECK_EQUAL( (size_t)9, range.size() );
298  CHECK_EQUAL( (EntityHandle)12, *result );
299 
300  // test erase from back of first node
301  range.clear();
302  range.insert( 5, 10 );
303  range.insert( 12, 20 );
304  result = range.erase( range.begin() + 2, range.begin() + 6 );
305  CHECK_EQUAL( (EntityHandle)5, range.front() );
306  CHECK_EQUAL( (EntityHandle)20, range.back() );
307  CHECK_EQUAL( (size_t)11, range.size() );
308  CHECK_EQUAL( (EntityHandle)12, *result );
309 
310  // test erase from middle of first node
311  range.clear();
312  range.insert( 5, 10 );
313  range.insert( 12, 20 );
314  result = range.erase( range.begin() + 2, range.begin() + 5 );
315  CHECK_EQUAL( (EntityHandle)5, range.front() );
316  CHECK_EQUAL( (EntityHandle)20, range.back() );
317  CHECK_EQUAL( (size_t)12, range.size() );
318  CHECK_EQUAL( (EntityHandle)10, *result );
319 
320  // test erase spanning two nodes
321  range.clear();
322  range.insert( 5, 10 );
323  range.insert( 12, 20 );
324  result = range.erase( range.begin() + 3, range.begin() + 7 );
325  CHECK_EQUAL( (EntityHandle)5, range.front() );
326  CHECK_EQUAL( (EntityHandle)20, range.back() );
327  CHECK_EQUAL( (size_t)11, range.size() );
328  CHECK_EQUAL( (EntityHandle)13, *result );
329 
330  // test erase of first node and part of second
331  range.clear();
332  range.insert( 5, 10 );
333  range.insert( 12, 20 );
334  result = range.erase( range.begin(), range.begin() + 7 );
335  CHECK_EQUAL( (EntityHandle)13, range.front() );
336  CHECK_EQUAL( (EntityHandle)20, range.back() );
337  CHECK_EQUAL( (size_t)8, range.size() );
338  CHECK_EQUAL( (EntityHandle)13, *result );
339 
340  // test erase spanning three nodes
341  range.clear();
342  range.insert( 5, 10 );
343  range.insert( 12, 20 );
344  range.insert( 100, 101 );
345  result = range.erase( range.begin() + 3, range.begin() + 16 );
346  CHECK_EQUAL( (EntityHandle)5, range.front() );
347  CHECK_EQUAL( (EntityHandle)101, range.back() );
348  CHECK_EQUAL( (size_t)4, range.size() );
349  CHECK_EQUAL( (EntityHandle)101, *result );
350 
351  // test erase from start of second node
352  range.clear();
353  range.insert( 5, 10 );
354  range.insert( 12, 20 );
355  result = range.erase( range.begin() + 6, range.begin() + 8 );
356  CHECK_EQUAL( (EntityHandle)5, range.front() );
357  CHECK_EQUAL( (EntityHandle)20, range.back() );
358  CHECK_EQUAL( (size_t)13, range.size() );
359  CHECK_EQUAL( (EntityHandle)14, *result );
360 
361  // test erase from back of last node
362  range.clear();
363  range.insert( 5, 10 );
364  range.insert( 12, 20 );
365  result = range.erase( range.begin() + 13, range.end() );
366  CHECK_EQUAL( (EntityHandle)5, range.front() );
367  CHECK_EQUAL( (EntityHandle)18, range.back() );
368  CHECK_EQUAL( (size_t)13, range.size() );
369  CHECK( result == range.end() );
370 
371  // test erase part of first node through end
372  range.clear();
373  range.insert( 5, 10 );
374  range.insert( 12, 20 );
375  result = range.erase( range.begin() + 4, range.end() );
376  CHECK_EQUAL( (EntityHandle)5, range.front() );
377  CHECK_EQUAL( (EntityHandle)8, range.back() );
378  CHECK_EQUAL( (size_t)4, range.size() );
379  CHECK( result == range.end() );
380 
381  // test erase of single node
382  range.clear();
383  range.insert( 5, 10 );
384  result = range.erase( range.begin(), range.end() );
385  CHECK_EQUAL( (size_t)0, range.size() );
386  CHECK( result == range.end() );
387 
388  // test erase of multi-node range
389  range.clear();
390  range.insert( 5, 10 );
391  range.insert( 12, 20 );
392  range.insert( 100, 101 );
393  result = range.erase( range.begin(), range.end() );
394  CHECK_EQUAL( (size_t)0, range.size() );
395  CHECK( result == range.end() );
396 
397  // test erase nothing
398  range.clear();
399  range.insert( 5, 10 );
400  range.insert( 12, 20 );
401  result = range.erase( range.begin() + 3, range.begin() + 3 );
402  CHECK_EQUAL( (EntityHandle)5, range.front() );
403  CHECK_EQUAL( (EntityHandle)20, range.back() );
404  CHECK_EQUAL( (size_t)15, range.size() );
405  CHECK_EQUAL( (EntityHandle)8, *result );
406 
407  // test iterators before erase remain valid
408  Range::iterator a, b, c;
409  range.clear();
410  range.insert( 5, 10 );
411  range.insert( 12, 20 );
412  a = range.begin();
413  b = range.begin() + 6;
414  c = range.begin() + 8;
415  result = range.erase( range.begin() + 9, range.end() );
416  CHECK( a == range.begin() );
417  CHECK( b == range.begin() + 6 );
418  CHECK( c == range.begin() + 8 );
419  CHECK( result == range.end() );
420 
421  // test iterators before erase remain valid, single value case
422  range.clear();
423  range.insert( 5, 10 );
424  range.insert( 12, 20 );
425  a = range.begin();
426  b = range.begin() + 6;
427  c = range.begin() + 8;
428  result = range.erase( range.begin() + 9 );
429  CHECK_EQUAL( (EntityHandle)5, range.front() );
430  CHECK_EQUAL( (EntityHandle)20, range.back() );
431  CHECK_EQUAL( (size_t)14, range.size() );
432  CHECK( a == range.begin() );
433  CHECK( b == range.begin() + 6 );
434  CHECK( c == range.begin() + 8 );
435  CHECK_EQUAL( (EntityHandle)16, *result );
436 }

References moab::Range::back(), moab::Range::begin(), CHECK, CHECK_EQUAL, moab::Range::clear(), moab::Range::end(), moab::Range::erase(), moab::Range::front(), moab::Range::insert(), and moab::Range::size().

Referenced by main().

◆ insert_hint_test()

void insert_hint_test ( )

Definition at line 31 of file range_test.cpp.

32 {
33  const EntityHandle pairs[][2] = { { 4980, 4981 }, { 4985, 4986 }, { 4990, 4990 }, { 5886, 5886 }, { 5888, 5890 },
34  { 5890, 5890 }, { 5886, 5888 }, { 5890, 5890 }, { 5894, 5894 }, { 5899, 5899 } };
35  const int num_pairs = sizeof( pairs ) / sizeof( pairs[0] );
36  const EntityHandle exp_pairs[][2] = { { 4980, 4981 }, { 4985, 4986 }, { 4990, 4990 },
37  { 5886, 5890 }, { 5894, 5894 }, { 5899, 5899 } };
38  const int num_exp = sizeof( exp_pairs ) / sizeof( exp_pairs[0] );
39 
40  Range range;
41  Range::iterator it = range.begin();
42  for( int i = 0; i < num_pairs; ++i )
43  it = range.insert( it, pairs[i][0], pairs[i][1] );
44 
45  Range::const_pair_iterator pit = range.const_pair_begin();
46  for( int i = 0; i < num_exp; ++i )
47  {
48  CHECK( pit != range.const_pair_end() );
49  CHECK_EQUAL( exp_pairs[i][0], pit->first );
50  CHECK_EQUAL( exp_pairs[i][1], pit->second );
51  ++pit;
52  }
53  CHECK( pit == range.const_pair_end() );
54 }

References moab::Range::begin(), CHECK, CHECK_EQUAL, moab::Range::const_pair_begin(), moab::Range::const_pair_end(), and moab::Range::insert().

Referenced by main().

◆ intersect_test()

void intersect_test ( )

Definition at line 68 of file range_test.cpp.

69 {
70  Range r1, r2, rhs;
71 
72  // equal start/end
73  r1.insert( h1, h5 );
74  r1.insert( h10, h15 );
75  r2.insert( h5, h10 );
76  r2.insert( h15, h20 );
77  rhs = intersect( r1, r2 );
78  CHECK_EQUAL( (size_t)3, rhs.size() );
79 
80  // identical ranges test
81  r1.clear();
82  r2.clear();
83  rhs.clear();
84  r1.insert( h1, h5 );
85  r1.insert( h10, h20 );
86  r2.insert( h1, h5 );
87  r2.insert( h10, h20 );
88  rhs = intersect( r1, r2 );
89  CHECK_EQUAL( r1.size(), rhs.size() );
90  CHECK_EQUAL( r2.size(), rhs.size() );
91 
92  // off by one test
93  r1.clear();
94  r2.clear();
95  rhs.clear();
96  r1.insert( h1, h4 );
97  r1.insert( h10, h15 );
98  r2.insert( h5, h9 );
99  r2.insert( h16, h20 );
100  rhs = intersect( r1, r2 );
101  CHECK( rhs.empty() );
102 
103  // interior test
104  r1.clear();
105  r2.clear();
106  rhs.clear();
107  r1.insert( h1, h20 );
108  r2.insert( h5, h10 );
109  rhs = intersect( r1, r2 );
110  CHECK_EQUAL( r2.size(), rhs.size() );
111 
112  // half-above test
113  r1.clear();
114  r2.clear();
115  rhs.clear();
116  r1.insert( h1, h10 );
117  r2.insert( h5, h20 );
118  rhs = intersect( r1, r2 );
119  CHECK_EQUAL( (size_t)( h10 - h5 + 1 ), rhs.size() );
120 
121  // half-below test
122  r1.clear();
123  r2.clear();
124  rhs.clear();
125  r1.insert( h5, h20 );
126  r2.insert( h1, h10 );
127  rhs = intersect( r1, r2 );
128  CHECK_EQUAL( (size_t)( h10 - h5 + 1 ), rhs.size() );
129 }

References CHECK, CHECK_EQUAL, moab::Range::clear(), moab::Range::empty(), h1, h10, h15, h16, h20, h4, h5, h9, moab::Range::insert(), moab::intersect(), and moab::Range::size().

Referenced by main().

◆ main()

int main ( )

Definition at line 16 of file range_test.cpp.

17 {
18  int rval = 0;
19  rval += RUN_TEST( insert_hint_test );
20  rval += RUN_TEST( intersect_test );
21  rval += RUN_TEST( merge_test );
22  rval += RUN_TEST( const_pair_iterator_test );
23  rval += RUN_TEST( swap_test );
24  rval += RUN_TEST( subtract_test );
25  rval += RUN_TEST( subset_by_dimension_test );
26  rval += RUN_TEST( erase_test );
27  rval += RUN_TEST( contains_test );
28  return rval;
29 }

References const_pair_iterator_test(), contains_test(), erase_test(), insert_hint_test(), intersect_test(), merge_test(), RUN_TEST, subset_by_dimension_test(), subtract_test(), and swap_test().

◆ merge_test()

void merge_test ( )

Definition at line 131 of file range_test.cpp.

132 {
133  Range r1, r2;
134 
135  // merge all test
136  r1.clear();
137  r2.clear();
138  r1.insert( h1, h5 );
139  r1.insert( h10, h15 );
140  r2 = r1;
141  r1.merge( r2 );
142  CHECK_EQUAL( r2.size(), r1.size() );
143 
144  // merge subset test
145  r1.clear();
146  r2.clear();
147  r1.insert( h1, h5 );
148  r1.insert( h10, h15 );
149  Range::const_iterator i1 = r1.begin();
150  Range::const_iterator i2 = r1.end();
151  i1 += 2;
152  i2 -= 2;
153  r2.merge( i1, i2 );
154  CHECK_EQUAL( r1.size() - 4, r2.size() );
155 }

References moab::Range::begin(), CHECK_EQUAL, moab::Range::clear(), moab::Range::end(), h1, h10, h15, h5, moab::Range::insert(), moab::Range::merge(), and moab::Range::size().

Referenced by main().

◆ subset_by_dimension_test()

void subset_by_dimension_test ( )

Definition at line 260 of file range_test.cpp.

261 {
262  Range r1, r2;
263 
264  // subset_by_dimension test
265  r1.insert( h1 );
266  r1.insert( h4 );
267  r1.insert( hh1 );
268  r1.insert( hh3 );
269  r2 = r1.subset_by_dimension( 3 );
270  CHECK_EQUAL( (size_t)2, r2.size() );
271  CHECK_EQUAL( hh1, r2.front() );
272  CHECK_EQUAL( hh3, r2.back() );
273 }

References moab::Range::back(), CHECK_EQUAL, moab::Range::front(), h1, h4, hh1, hh3, moab::Range::insert(), moab::Range::size(), and moab::Range::subset_by_dimension().

Referenced by main().

◆ subtract_test()

void subtract_test ( )

Definition at line 231 of file range_test.cpp.

232 {
233  Range r1, r2, r3;
234 
235  r1.clear();
236  r2.clear();
237  r1.insert( h1 );
238  r1.insert( h4 );
239  r1.insert( h5 );
240  r2.insert( h4 );
241  r3 = subtract( r1, r2 );
242  CHECK_EQUAL( (size_t)2, r3.size() );
243  CHECK( r3.find( h1 ) != r3.end() );
244  CHECK( r3.find( h5 ) != r3.end() );
245  CHECK( r3.find( h4 ) == r3.end() );
246 
247  // destination empty
248  r1.clear();
249  r2.clear();
250  r1.insert( h1 );
251  r1.insert( h4 );
252  r1.insert( h5 );
253  r3 = subtract( r1, r2 );
254  CHECK_EQUAL( (size_t)3, r3.size() );
255  CHECK( r3.find( h1 ) != r3.end() );
256  CHECK( r3.find( h4 ) != r3.end() );
257  CHECK( r3.find( h5 ) != r3.end() );
258 }

References CHECK, CHECK_EQUAL, moab::Range::clear(), moab::Range::end(), moab::Range::find(), h1, h4, h5, moab::Range::insert(), moab::Range::size(), and moab::subtract().

Referenced by main().

◆ swap_test()

void swap_test ( )

Definition at line 178 of file range_test.cpp.

179 {
180  Range r1, r2;
181 
182  // both non-empty
183  r1.clear();
184  r2.clear();
185  r1.insert( h1 );
186  r1.insert( h4 );
187  r1.insert( h5 );
188  r2.insert( h9 );
189  r1.swap( r2 );
190  CHECK_EQUAL( (size_t)1, r1.size() );
191  CHECK_EQUAL( (size_t)3, r2.size() );
192  CHECK( r1.find( h9 ) != r1.end() );
193  CHECK( r2.find( h1 ) != r2.end() );
194  CHECK( r2.find( h4 ) != r2.end() );
195  CHECK( r2.find( h5 ) != r2.end() );
196 
197  // destination empty
198  r1.clear();
199  r2.clear();
200  r2.insert( h1 );
201  r2.insert( h4 );
202  r2.insert( h5 );
203  r1.swap( r2 );
204  CHECK_EQUAL( (size_t)3, r1.size() );
205  CHECK_EQUAL( (size_t)0, r2.size() );
206  CHECK( r1.find( h1 ) != r1.end() );
207  CHECK( r1.find( h4 ) != r1.end() );
208  CHECK( r1.find( h5 ) != r1.end() );
209 
210  // source empty
211  r1.clear();
212  r2.clear();
213  r1.insert( h1 );
214  r1.insert( h4 );
215  r1.insert( h5 );
216  r1.swap( r2 );
217  CHECK_EQUAL( (size_t)0, r1.size() );
218  CHECK_EQUAL( (size_t)3, r2.size() );
219  CHECK( r2.find( h1 ) != r2.end() );
220  CHECK( r2.find( h4 ) != r2.end() );
221  CHECK( r2.find( h5 ) != r2.end() );
222 
223  // both empty
224  r1.clear();
225  r2.clear();
226  r1.swap( r2 );
227  CHECK( r1.empty() );
228  CHECK( r2.empty() );
229 }

References CHECK, CHECK_EQUAL, moab::Range::clear(), moab::Range::empty(), moab::Range::end(), moab::Range::find(), h1, h4, h5, h9, moab::Range::insert(), moab::Range::size(), and moab::Range::swap().

Referenced by main().

Variable Documentation

◆ h1

const EntityHandle h1 = CREATE_HANDLE( MBVERTEX, 1 )

Definition at line 57 of file range_test.cpp.

Referenced by const_pair_iterator_test(), intersect_test(), mb_type_is_maxtype_test(), merge_test(), moab::OrientedBoxTreeTool::TrvStats::print(), qsort_comp_handles(), subset_by_dimension_test(), subtract_test(), swap_test(), test_get_set(), test_get_set_bit(), test_get_set_variable_length(), and test_read_adjacencies().

◆ h10

const EntityHandle h10 = CREATE_HANDLE( MBVERTEX, 10 )

Definition at line 61 of file range_test.cpp.

Referenced by intersect_test(), and merge_test().

◆ h15

const EntityHandle h15 = CREATE_HANDLE( MBVERTEX, 15 )

Definition at line 62 of file range_test.cpp.

Referenced by intersect_test(), and merge_test().

◆ h16

const EntityHandle h16 = CREATE_HANDLE( MBVERTEX, 16 )

Definition at line 63 of file range_test.cpp.

Referenced by intersect_test().

◆ h20

const EntityHandle h20 = CREATE_HANDLE( MBVERTEX, 20 )

Definition at line 64 of file range_test.cpp.

Referenced by intersect_test().

◆ h4

const EntityHandle h4 = CREATE_HANDLE( MBVERTEX, 4 )

Definition at line 58 of file range_test.cpp.

Referenced by const_pair_iterator_test(), intersect_test(), moab::OrientedBoxTreeTool::TrvStats::print(), subset_by_dimension_test(), subtract_test(), and swap_test().

◆ h5

const EntityHandle h5 = CREATE_HANDLE( MBVERTEX, 5 )

Definition at line 59 of file range_test.cpp.

Referenced by const_pair_iterator_test(), intersect_test(), merge_test(), subtract_test(), and swap_test().

◆ h9

const EntityHandle h9 = CREATE_HANDLE( MBVERTEX, 9 )

Definition at line 60 of file range_test.cpp.

Referenced by intersect_test(), and swap_test().

◆ hh1

const EntityHandle hh1 = CREATE_HANDLE( MBHEX, 1 )

Definition at line 65 of file range_test.cpp.

Referenced by subset_by_dimension_test().

◆ hh3

const EntityHandle hh3 = CREATE_HANDLE( MBHEX, 3 )

Definition at line 66 of file range_test.cpp.

Referenced by subset_by_dimension_test().