MOAB: Mesh Oriented datABase  (version 5.5.0)
TestTypeSequenceManager.cpp
Go to the documentation of this file.
1 #include <thread>
2 #include <set>
3 
4 #include "TypeSequenceManager.hpp"
5 #include "EntitySequence.hpp"
6 #include "SequenceData.hpp"
7 #include "TestUtil.hpp"
8 #include "moab/Error.hpp"
9 
10 using namespace moab;
11 
12 void test_basic();
13 void test_lower_bound();
14 void test_upper_bound();
15 void test_find();
16 void test_get_entities();
17 void test_insert_sequence_merge();
18 void test_insert_sequence_nomerge();
19 void test_remove_sequence();
20 void test_replace_subsequence();
21 void test_erase();
22 void test_find_free_handle();
23 void test_find_free_sequence();
24 void test_is_free_sequence();
25 void test_is_free_handle();
26 #ifndef MOAB_FORCE_32_BIT_HANDLES
27 void test_threaded_access( int n_threads );
28 void test_single_thread_access();
29 #endif
30 void test_multi_thread_access();
31 
32 void regression_svn1952();
33 void regression_svn1958();
34 void regression_svn1960();
35 
36 /* Construct sequence of vertex handles containing
37  the ID ranges: { [3,7], [100,111], [1001] }
38  referencing a SequnceData with the range [1,22000]
39  */
40 void make_basic_sequence( TypeSequenceManager& seq );
41 void make_basic_sequence( TypeSequenceManager& seq,
42  EntitySequence*& seq3to7,
43  EntitySequence*& seq100to111,
44  EntitySequence*& seq1001 );
45 
46 /* Compare expected sequence contents to actual contents.
47  * Also does some consistency checks.
48  */
49 bool seqman_equal( const EntityHandle pair_array[][2], unsigned num_pairs, const TypeSequenceManager& seqman );
50 
51 /*
52  * Insert a sequence into a sequence manager. Delete passed
53  * sequence (and optionally SequenceData) if insertion fails.
54  */
55 ErrorCode insert_seq( TypeSequenceManager& seqman,
56  EntityHandle start_handle,
57  EntityID count,
58  SequenceData* data,
59  bool del_data = false );
60 
61 int main()
62 {
63  if( RUN_TEST( test_basic ) )
64  {
65  printf( "BASIC USE TEST FAILED\nCANNOT TEST FURTHER\n" );
66  return 1;
67  }
68 
69  int error_count = 0;
70  error_count += RUN_TEST( test_lower_bound );
71  error_count += RUN_TEST( test_upper_bound );
72  error_count += RUN_TEST( test_find );
73  error_count += RUN_TEST( test_get_entities );
74  error_count += RUN_TEST( test_insert_sequence_merge );
75  error_count += RUN_TEST( test_insert_sequence_nomerge );
76  error_count += RUN_TEST( test_remove_sequence );
77  error_count += RUN_TEST( test_replace_subsequence );
78  error_count += RUN_TEST( test_erase );
79  error_count += RUN_TEST( test_find_free_handle );
80  error_count += RUN_TEST( test_find_free_sequence );
81  error_count += RUN_TEST( test_is_free_sequence );
82 #ifndef MOAB_FORCE_32_BIT_HANDLES
83  error_count += RUN_TEST( test_single_thread_access );
84  error_count += RUN_TEST( test_multi_thread_access );
85 #endif
86  error_count += RUN_TEST( regression_svn1952 );
87  error_count += RUN_TEST( regression_svn1958 );
88  error_count += RUN_TEST( regression_svn1960 );
89 
90  if( !error_count )
91  printf( "ALL TESTS PASSED\n" );
92  else
93  printf( "%d TESTS FAILED\n", error_count );
94 
95  return error_count;
96 }
97 
98 class DumSeq : public EntitySequence
99 {
100  private:
101  int valsPerEnt;
102 
103  public:
104  DumSeq( EntityHandle start, EntityID count, SequenceData* data2, int vals_per_ent = 0 )
105  : EntitySequence( start, count, data2 ), valsPerEnt( vals_per_ent )
106  {
107  }
108  DumSeq( SequenceData* data2, int vals_per_ent = 0 )
109  : EntitySequence( data2->start_handle(), data2->size(), data2 ), valsPerEnt( vals_per_ent )
110  {
111  }
112 
113  DumSeq( DumSeq& split_from, EntityHandle here )
114  : EntitySequence( split_from, here ), valsPerEnt( split_from.valsPerEnt )
115  {
116  }
117 
118  virtual ~DumSeq() {}
119 
120  EntitySequence* split( EntityHandle here )
121  {
122  return new DumSeq( *this, here );
123  }
124 
125  SequenceData* create_data_subset( EntityHandle a, EntityHandle b ) const
126  {
127  return data()->subset( a, b, 0 );
128  }
129 
130  void get_const_memory_use( unsigned long& a, unsigned long& b ) const
131  {
132  a = b = 0;
133  }
134  unsigned long get_per_entity_memory_use( EntityHandle, EntityHandle ) const
135  {
136  return 0;
137  }
138 
139  int values_per_entity() const
140  {
141  return valsPerEnt;
142  }
143 };
144 
145 void make_basic_sequence( TypeSequenceManager& seqman )
146 {
147  EntitySequence *s, *t, *u;
148  make_basic_sequence( seqman, s, t, u );
149 }
150 
151 ErrorCode insert_seq( TypeSequenceManager& seqman,
152  EntityHandle start_handle,
153  EntityID count,
154  SequenceData* data,
155  bool del_data )
156 {
157  EntitySequence* seq = new DumSeq( start_handle, count, data );
158  ErrorCode rval = seqman.insert_sequence( seq );
159  if( MB_SUCCESS != rval )
160  {
161  delete seq;
162  if( del_data ) delete data;
163  }
164  else
165  {
166  CHECK( start_handle >= seq->start_handle() );
167  CHECK( start_handle + count - 1 <= seq->end_handle() );
168  }
169  return rval;
170 }
171 
172 void make_basic_sequence( TypeSequenceManager& seqman,
173  EntitySequence*& seq1,
174  EntitySequence*& seq2,
175  EntitySequence*& seq3 )
176 {
177  CHECK( seqman.empty() );
178  CHECK_EQUAL( (EntityID)0, seqman.get_number_entities() );
179 
180  SequenceData* data = new SequenceData( 0, 1, 22000 );CHECK_ERR( insert_seq( seqman, 3, 5, data ) );CHECK_ERR( insert_seq( seqman, 100, 12, data ) );CHECK_ERR( insert_seq( seqman, 1001, 1, data ) );
181 
182  CHECK( !seqman.empty() );
183  CHECK_EQUAL( (EntityID)18, seqman.get_number_entities() );
184 
185  TypeSequenceManager::iterator iter = seqman.begin();
186  CHECK( iter != seqman.end() );
187  seq1 = *iter;
188  CHECK_EQUAL( (EntityHandle)3, seq1->start_handle() );
189  CHECK_EQUAL( (EntityHandle)7, seq1->end_handle() );
190  CHECK_EQUAL( data, seq1->data() );
191  CHECK_EQUAL( (EntityID)5, seq1->size() );
192 
193  ++iter;
194  CHECK( iter != seqman.end() );
195  seq2 = *iter;
196  CHECK_EQUAL( (EntityHandle)100, seq2->start_handle() );
197  CHECK_EQUAL( (EntityHandle)111, seq2->end_handle() );
198  CHECK_EQUAL( data, seq2->data() );
199  CHECK_EQUAL( (EntityID)12, seq2->size() );
200 
201  ++iter;
202  seq3 = *iter;
203  CHECK( iter != seqman.end() );
204  CHECK_EQUAL( (EntityHandle)1001, seq3->start_handle() );
205  CHECK_EQUAL( (EntityHandle)1001, seq3->end_handle() );
206  CHECK_EQUAL( data, seq3->data() );
207  CHECK_EQUAL( (EntityID)1, seq3->size() );
208 
209  ++iter;
210  CHECK( iter == seqman.end() );
211 }
212 
213 void test_basic()
214 {
215  TypeSequenceManager seqman;
216  make_basic_sequence( seqman );
217 }
218 
219 void test_lower_bound()
220 {
221  TypeSequenceManager::const_iterator i;
222  TypeSequenceManager seqman;
223  EntitySequence *seq1, // 3 to 7
224  *seq2, // 100 to 111
225  *seq3; // 1001
226  make_basic_sequence( seqman, seq1, seq2, seq3 );
227 
228  i = seqman.lower_bound( 2 );
229  CHECK_EQUAL( seq1, *i );
230  i = seqman.lower_bound( 3 );
231  CHECK_EQUAL( seq1, *i );
232  i = seqman.lower_bound( 4 );
233  CHECK_EQUAL( seq1, *i );
234  i = seqman.lower_bound( 7 );
235  CHECK_EQUAL( seq1, *i );
236 
237  i = seqman.lower_bound( 8 );
238  CHECK_EQUAL( seq2, *i );
239  i = seqman.lower_bound( 99 );
240  CHECK_EQUAL( seq2, *i );
241  i = seqman.lower_bound( 100 );
242  CHECK_EQUAL( seq2, *i );
243  i = seqman.lower_bound( 110 );
244  CHECK_EQUAL( seq2, *i );
245  i = seqman.lower_bound( 111 );
246  CHECK_EQUAL( seq2, *i );
247 
248  i = seqman.lower_bound( 112 );
249  CHECK_EQUAL( seq3, *i );
250  i = seqman.lower_bound( 1000 );
251  CHECK_EQUAL( seq3, *i );
252  i = seqman.lower_bound( 1001 );
253  CHECK_EQUAL( seq3, *i );
254 
255  i = seqman.lower_bound( 1002 );
256  CHECK( i == seqman.end() );
257 }
258 
259 void test_upper_bound()
260 {
261  TypeSequenceManager::const_iterator i;
262  TypeSequenceManager seqman;
263  EntitySequence *seq1, // 3 to 7
264  *seq2, // 100 to 111
265  *seq3; // 1001
266  make_basic_sequence( seqman, seq1, seq2, seq3 );
267 
268  i = seqman.upper_bound( 2 );
269  CHECK_EQUAL( seq1, *i );
270 
271  i = seqman.upper_bound( 3 );
272  CHECK_EQUAL( seq2, *i );
273  i = seqman.upper_bound( 4 );
274  CHECK_EQUAL( seq2, *i );
275  i = seqman.upper_bound( 7 );
276  CHECK_EQUAL( seq2, *i );
277  i = seqman.upper_bound( 8 );
278  CHECK_EQUAL( seq2, *i );
279  i = seqman.upper_bound( 99 );
280  CHECK_EQUAL( seq2, *i );
281 
282  i = seqman.upper_bound( 100 );
283  CHECK_EQUAL( seq3, *i );
284  i = seqman.upper_bound( 110 );
285  CHECK_EQUAL( seq3, *i );
286  i = seqman.upper_bound( 111 );
287  CHECK_EQUAL( seq3, *i );
288  i = seqman.upper_bound( 112 );
289  CHECK_EQUAL( seq3, *i );
290  i = seqman.upper_bound( 1000 );
291  CHECK_EQUAL( seq3, *i );
292 
293  i = seqman.upper_bound( 1001 );
294  CHECK( i == seqman.end() );
295 }
296 
297 void test_find()
298 {
299  TypeSequenceManager seqman;
300  EntitySequence *seq1, // 3 to 7
301  *seq2, // 100 to 111
302  *seq3, // 1001
303  *seq;
304  make_basic_sequence( seqman, seq1, seq2, seq3 );
305 
306  seq = seqman.find( 2 );
307  CHECK_EQUAL( NULL, seq );
308  seq = seqman.find( 3 );
309  CHECK_EQUAL( seq1, seq );
310  seq = seqman.find( 4 );
311  CHECK_EQUAL( seq1, seq );
312  seq = seqman.find( 7 );
313  CHECK_EQUAL( seq1, seq );
314  seq = seqman.find( 8 );
315  CHECK_EQUAL( NULL, seq );
316 
317  seq = seqman.find( 99 );
318  CHECK_EQUAL( NULL, seq );
319  seq = seqman.find( 100 );
320  CHECK_EQUAL( seq2, seq );
321  seq = seqman.find( 110 );
322  CHECK_EQUAL( seq2, seq );
323  seq = seqman.find( 111 );
324  CHECK_EQUAL( seq2, seq );
325  seq = seqman.find( 112 );
326  CHECK_EQUAL( NULL, seq );
327 
328  seq = seqman.find( 1000 );
329  CHECK_EQUAL( NULL, seq );
330  seq = seqman.find( 1001 );
331  CHECK_EQUAL( seq3, seq );
332  seq = seqman.find( 1002 );
333  CHECK_EQUAL( NULL, seq );
334 }
335 
336 bool seqman_equal( const EntityHandle pair_array[][2], unsigned num_pairs, const TypeSequenceManager& seqman )
337 {
338  unsigned i;
339  TypeSequenceManager::const_iterator j = seqman.begin();
340  EntitySequence* seq = 0;
341  for( i = 0; i < num_pairs; ++i, ++j )
342  {
343  if( j == seqman.end() ) break;
344 
345  if( seq && seq->end_handle() >= ( *j )->start_handle() )
346  {
347  printf( "Sequence [%lu,%lu] overlaps sequence [%lu,%lu]\n",
348  (unsigned long)ID_FROM_HANDLE( seq->start_handle() ),
349  (unsigned long)ID_FROM_HANDLE( seq->end_handle() ),
350  (unsigned long)ID_FROM_HANDLE( ( *j )->start_handle() ),
351  (unsigned long)ID_FROM_HANDLE( ( *j )->end_handle() ) );
352  return false;
353  }
354 
355  if( seq && seq->data() != ( *j )->data() && seq->data()->end_handle() >= ( *j )->data()->start_handle() )
356  {
357  printf( "SequenceData [%lu,%lu] overlaps SequenceData [%lu,%lu]\n",
358  (unsigned long)ID_FROM_HANDLE( seq->data()->start_handle() ),
359  (unsigned long)ID_FROM_HANDLE( seq->data()->end_handle() ),
360  (unsigned long)ID_FROM_HANDLE( ( *j )->data()->start_handle() ),
361  (unsigned long)ID_FROM_HANDLE( ( *j )->data()->end_handle() ) );
362  return false;
363  }
364 
365  seq = *j;
366  if( seq->start_handle() > seq->end_handle() )
367  {
368  printf( "Inverted sequence [%lu,%lu]\n", (unsigned long)ID_FROM_HANDLE( seq->start_handle() ),
369  (unsigned long)ID_FROM_HANDLE( seq->end_handle() ) );
370  return false;
371  }
372 
373  if( pair_array[i][0] != seq->start_handle() || pair_array[i][1] != seq->end_handle() ) break;
374 
375  if( seq->data()->start_handle() > seq->start_handle() || seq->data()->end_handle() < seq->end_handle() )
376  {
377  printf( "Sequence [%lu,%lu] has data [%lu,%lu]\n", (unsigned long)ID_FROM_HANDLE( seq->start_handle() ),
378  (unsigned long)ID_FROM_HANDLE( seq->end_handle() ),
379  (unsigned long)ID_FROM_HANDLE( seq->data()->start_handle() ),
380  (unsigned long)ID_FROM_HANDLE( seq->data()->end_handle() ) );
381  return false;
382  }
383  }
384 
385  if( i == num_pairs && j == seqman.end() ) return true;
386 
387  if( i < num_pairs )
388  printf( "Sequence Mismatch: Expected: [%lu,%lu], got ", (unsigned long)ID_FROM_HANDLE( pair_array[i][0] ),
389  (unsigned long)ID_FROM_HANDLE( pair_array[i][1] ) );
390  else
391  printf( "Sequence Mismatch: Expected END, got " );
392 
393  if( j == seqman.end() )
394  printf( "END.\n" );
395  else
396  printf( "[%lu,%lu]\n", (unsigned long)ID_FROM_HANDLE( ( *j )->start_handle() ),
397  (unsigned long)ID_FROM_HANDLE( ( *j )->end_handle() ) );
398 
399  return false;
400 }
401 
402 void test_get_entities()
403 {
404  TypeSequenceManager seqman;
405  make_basic_sequence( seqman );
406 
407  CHECK( !seqman.empty() );
408  CHECK_EQUAL( (EntityID)18, seqman.get_number_entities() );
409 
410  Range entities;
411  seqman.get_entities( entities );
412  CHECK_EQUAL( (size_t)18, entities.size() );
413 
414  EntityHandle pairs[][2] = { { 3, 7 }, { 100, 111 }, { 1001, 1001 } };
415  CHECK( seqman_equal( pairs, 3, seqman ) );
416 }
417 
418 void test_insert_sequence_merge()
419 {
420  TypeSequenceManager seqman;
421  make_basic_sequence( seqman );
422  SequenceData* data = ( *seqman.begin() )->data();
423 
424  // append a sequence
425  CHECK_ERR( insert_seq( seqman, 1003, 1, data ) );
426  EntityHandle exp1[][2] = { { 3, 7 }, { 100, 111 }, { 1001, 1001 }, { 1003, 1003 } };
427  CHECK( seqman_equal( exp1, 4, seqman ) );
428 
429  // prepend a sequence
430  CHECK_ERR( insert_seq( seqman, 1, 1, data ) );
431  EntityHandle exp2[][2] = { { 1, 1 }, { 3, 7 }, { 100, 111 }, { 1001, 1001 }, { 1003, 1003 } };
432  CHECK( seqman_equal( exp2, 5, seqman ) );
433 
434  // insert sequence in middle
435  CHECK_ERR( insert_seq( seqman, 150, 11, data ) );
436  EntityHandle exp3[][2] = { { 1, 1 }, { 3, 7 }, { 100, 111 }, { 150, 160 }, { 1001, 1001 }, { 1003, 1003 } };
437  CHECK( seqman_equal( exp3, 6, seqman ) );
438 
439  // merge sequence with predecessor
440  CHECK_ERR( insert_seq( seqman, 8, 13, data ) );
441  EntityHandle exp4[][2] = { { 1, 1 }, { 3, 20 }, { 100, 111 }, { 150, 160 }, { 1001, 1001 }, { 1003, 1003 } };
442  CHECK( seqman_equal( exp4, 6, seqman ) );
443 
444  // merge sequence with following one
445  CHECK_ERR( insert_seq( seqman, 87, 13, data ) );
446  EntityHandle exp5[][2] = { { 1, 1 }, { 3, 20 }, { 87, 111 }, { 150, 160 }, { 1001, 1001 }, { 1003, 1003 } };
447  CHECK( seqman_equal( exp5, 6, seqman ) );
448 
449  // merge sequence with two adjacent ones
450  CHECK_ERR( insert_seq( seqman, 2, 1, data ) );
451  EntityHandle exp6[][2] = { { 1, 20 }, { 87, 111 }, { 150, 160 }, { 1001, 1001 }, { 1003, 1003 } };
452  CHECK( seqman_equal( exp6, 5, seqman ) );
453 
454  // try to insert a sequence that overlaps on the end
455  CHECK_EQUAL( MB_ALREADY_ALLOCATED, insert_seq( seqman, 900, 1001, data ) );
456 
457  // try to insert a sequence that overlaps at the start
458  CHECK_EQUAL( MB_ALREADY_ALLOCATED, insert_seq( seqman, 111, 140, data ) );
459 }
460 
461 void test_insert_sequence_nomerge()
462 {
463  TypeSequenceManager seqman;
464 
465  // make sure inserting a sequence w/out a SequenceData fails
466  CHECK_EQUAL( MB_FAILURE, insert_seq( seqman, 1, 5, NULL ) );
467  CHECK( seqman.empty() );
468 
469  // Now set up a TypeSequenceManager for testing
470 
471  // Insert an EntitySequence for which the corresponding SequenceData
472  // is exactly the same size.
473  SequenceData* data1 = new SequenceData( 0, 3, 7 );
474  DumSeq* seq = new DumSeq( data1 );
475  ErrorCode rval = seqman.insert_sequence( seq );CHECK_ERR( rval );
476  if( MB_SUCCESS != rval )
477  {
478  delete seq;
479  delete data1;
480  return;
481  }
482 
483  // Insert an EntitySequence with additional room on both ends of
484  // the SequenceData
485  SequenceData* data2 = new SequenceData( 0, 100, 999 );
486  seq = new DumSeq( 200, 100, data2 );
487  rval = seqman.insert_sequence( seq );CHECK_ERR( rval );
488  if( MB_SUCCESS != rval )
489  {
490  delete seq;
491  delete data2;
492  return;
493  }
494 
495  // Insert another EntitySequence sharing the previous SequenceData
496  seq = new DumSeq( 400, 100, data2 );
497  rval = seqman.insert_sequence( seq );CHECK_ERR( rval );
498  if( MB_SUCCESS != rval )
499  {
500  delete seq;
501  return;
502  }
503 
504  // Setup complete, begin tests
505 
506  // Test inserting sequence that appends an existing sequence
507  // but overlaps underling SequenceData boundary
508  SequenceData* data = new SequenceData( 0, 999, 1000 );
509  seq = new DumSeq( data );
510  rval = seqman.insert_sequence( seq );
511  CHECK_EQUAL( MB_ALREADY_ALLOCATED, rval );
512  delete seq;
513  delete data;
514 
515  // Test inserting sequence that prepends an existing sequence
516  // but overlaps underling SequenceData boundary
517  data = new SequenceData( 0, 50, 199 );
518  seq = new DumSeq( data );
519  rval = seqman.insert_sequence( seq );
520  CHECK_EQUAL( MB_ALREADY_ALLOCATED, rval );
521  delete seq;
522  delete data;
523 
524  // Test fits within existing, but has different SequenceData
525  data = new SequenceData( 0, 500, 599 );
526  seq = new DumSeq( data );
527  rval = seqman.insert_sequence( seq );
528  CHECK_EQUAL( MB_ALREADY_ALLOCATED, rval );
529  delete seq;
530  delete data;
531 
532  // Make sure we're starting out with what we expect
533  EntityHandle exp1[][2] = { { 3, 7 }, { 200, 299 }, { 400, 499 } };
534  CHECK( seqman_equal( exp1, 3, seqman ) );
535 
536  // Test fits within existing, and has same data
537  CHECK_ERR( insert_seq( seqman, 600, 100, data2 ) );
538  EntityHandle exp2[][2] = { { 3, 7 }, { 200, 299 }, { 400, 499 }, { 600, 699 } };
539  CHECK( seqman_equal( exp2, 4, seqman ) );
540 
541  // Test is entirely outside existing data
542  CHECK_ERR( insert_seq( seqman, 2000, 2, new SequenceData( 0, 2000, 2001 ), true ) );
543  EntityHandle exp3[][2] = { { 3, 7 }, { 200, 299 }, { 400, 499 }, { 600, 699 }, { 2000, 2001 } };
544  CHECK( seqman_equal( exp3, 5, seqman ) );
545 
546  // Test abutts end of existing data
547  CHECK_ERR( insert_seq( seqman, 1000, 6, new SequenceData( 0, 1000, 1005 ), true ) );
548  EntityHandle exp4[][2] = { { 3, 7 }, { 200, 299 }, { 400, 499 }, { 600, 699 }, { 1000, 1005 }, { 2000, 2001 } };
549  CHECK( seqman_equal( exp4, 6, seqman ) );
550 
551  // Test abutts beginning of existing data
552  CHECK_ERR( insert_seq( seqman, 50, 50, new SequenceData( 0, 50, 99 ), true ) );
553  EntityHandle exp5[][2] = { { 3, 7 }, { 50, 99 }, { 200, 299 }, { 400, 499 },
554  { 600, 699 }, { 1000, 1005 }, { 2000, 2001 } };
555  CHECK( seqman_equal( exp5, 7, seqman ) );
556 }
557 
558 void test_remove_sequence()
559 {
560  TypeSequenceManager seqman;
561  EntitySequence *seq1, // 3 to 7
562  *seq2, // 100 to 111
563  *seq3; // 1001
564  make_basic_sequence( seqman, seq1, seq2, seq3 );
565 
566  // test removing something that hasn't been inserted
567  bool last;
568  DumSeq junk( 3, 5, NULL );
569  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, seqman.remove_sequence( &junk, last ) );
570  EntityHandle exp1[][2] = { { 3, 7 }, { 100, 111 }, { 1001, 1001 } };
571  CHECK( seqman_equal( exp1, 3, seqman ) );
572 
573  // remove the middle sequence
574  CHECK_ERR( seqman.remove_sequence( seq2, last ) );
575  CHECK( !last );
576  delete seq2;
577 
578  // remove the first sequence
579  CHECK_ERR( seqman.remove_sequence( seq1, last ) );
580  CHECK( !last );
581  delete seq1;
582 
583  // remove the last sequence
584  CHECK_ERR( seqman.remove_sequence( seq3, last ) );
585  CHECK( last );
586  SequenceData* data = seq3->data();
587  delete seq3;
588  delete data;
589 }
590 
591 void test_replace_subsequence()
592 {
593  ErrorCode rval;
594  TypeSequenceManager seqman;
595 
596  // create an initial set
597  SequenceData* data1 = new SequenceData( 0, 51, 950 );
598  rval = insert_seq( seqman, 101, 100, data1, true );CHECK_ERR( rval );
599  if( MB_SUCCESS != rval )
600  {
601  // data1 has been deleted by insert_seq call above
602  return;
603  }
604  rval = insert_seq( seqman, 301, 300, data1 );CHECK_ERR( rval );
605  rval = insert_seq( seqman, 701, 100, data1 );CHECK_ERR( rval );
606 
607  // try a sequence that is outside all existing data
608  SequenceData* data = new SequenceData( 0, 10, 20 );
609  DumSeq* seq = new DumSeq( data );
610  rval = seqman.replace_subsequence( seq, 0, 0 );
611  CHECK_EQUAL( MB_FAILURE, rval );
612  delete seq;
613  delete data;
614 
615  // try a sequence that overlaps the start of the data
616  data = new SequenceData( 0, 40, 60 );
617  seq = new DumSeq( data );
618  rval = seqman.replace_subsequence( seq, 0, 0 );
619  CHECK_EQUAL( MB_FAILURE, rval );
620  delete seq;
621  delete data;
622 
623  // try a sequence that is within the data but not within any sequence
624  data = new SequenceData( 0, 60, 70 );
625  seq = new DumSeq( data );
626  rval = seqman.replace_subsequence( seq, 0, 0 );
627  CHECK_EQUAL( MB_FAILURE, rval );
628  delete seq;
629  delete data;
630 
631  // try a sequence that overlaps an existing sequence
632  data = new SequenceData( 0, 60, 101 );
633  seq = new DumSeq( data );
634  rval = seqman.replace_subsequence( seq, 0, 0 );
635  CHECK_EQUAL( MB_FAILURE, rval );
636  delete seq;
637  delete data;
638 
639  // try a sequence that should work, but with a SequenceData that
640  // overlaps an existing sequence
641  data = new SequenceData( 0, 150, 200 );
642  seq = new DumSeq( 190, 200, data );
643  rval = seqman.replace_subsequence( seq, 0, 0 );
644  CHECK_EQUAL( MB_FAILURE, rval );
645  delete seq;
646  delete data;
647 
648  // check that we're starting with what we expect
649  EntityHandle exp1[][2] = { { 101, 200 }, { 301, 600 }, { 701, 800 } };
650  CHECK( seqman_equal( exp1, 3, seqman ) );
651 
652  // split at start of sequence
653  data = new SequenceData( 0, 101, 105 );
654  seq = new DumSeq( data );
655  rval = seqman.replace_subsequence( seq, 0, 0 );CHECK_ERR( rval );
656  if( MB_SUCCESS != rval )
657  {
658  delete seq;
659  delete data;
660  return;
661  }
662  EntityHandle exp2[][2] = { { 101, 105 }, { 106, 200 }, { 301, 600 }, { 701, 800 } };
663  CHECK( seqman_equal( exp2, 4, seqman ) );
664 
665  // split at end of sequence
666  data = new SequenceData( 0, 750, 800 );
667  seq = new DumSeq( data );
668  rval = seqman.replace_subsequence( seq, 0, 0 );CHECK_ERR( rval );
669  if( MB_SUCCESS != rval )
670  {
671  delete seq;
672  delete data;
673  return;
674  }
675  EntityHandle exp3[][2] = { { 101, 105 }, { 106, 200 }, { 301, 600 }, { 701, 749 }, { 750, 800 } };
676  CHECK( seqman_equal( exp3, 5, seqman ) );
677 
678  // split at middle of sequence
679  data = new SequenceData( 0, 400, 499 );
680  seq = new DumSeq( data );
681  rval = seqman.replace_subsequence( seq, 0, 0 );CHECK_ERR( rval );
682  if( MB_SUCCESS != rval )
683  {
684  delete seq;
685  delete data;
686  return;
687  }
688  EntityHandle exp4[][2] = { { 101, 105 }, { 106, 200 }, { 301, 399 }, { 400, 499 },
689  { 500, 600 }, { 701, 749 }, { 750, 800 } };
690  CHECK( seqman_equal( exp4, 7, seqman ) );
691 }
692 
693 void test_erase()
694 {
695  TypeSequenceManager seqman;
696  make_basic_sequence( seqman );
697  Error eh;
698 
699  // verify initial state
700  EntityHandle exp1[][2] = { { 3, 7 }, { 100, 111 }, { 1001, 1001 } };
701  CHECK( seqman_equal( exp1, 3, seqman ) );
702 
703  // try erasing invalid handles at start of existing sequence
704  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, seqman.erase( &eh, 1000, 1001 ) );
705  // try erasing invalid entities at end of existing sequence
706  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, seqman.erase( &eh, 3, 8 ) );
707  // verify initial state
708  CHECK( seqman_equal( exp1, 3, seqman ) );
709 
710  // erase from front of sequence
711  CHECK_ERR( seqman.erase( &eh, 3, 6 ) );
712  EntityHandle exp2[][2] = { { 7, 7 }, { 100, 111 }, { 1001, 1001 } };
713  CHECK( seqman_equal( exp2, 3, seqman ) );
714 
715  // erase from end of sequence
716  CHECK_ERR( seqman.erase( &eh, 110, 111 ) );
717  EntityHandle exp3[][2] = { { 7, 7 }, { 100, 109 }, { 1001, 1001 } };
718  CHECK( seqman_equal( exp3, 3, seqman ) );
719 
720  // erase from middle of sequence
721  CHECK_ERR( seqman.erase( &eh, 105, 107 ) );
722  EntityHandle exp4[][2] = { { 7, 7 }, { 100, 104 }, { 108, 109 }, { 1001, 1001 } };
723  CHECK( seqman_equal( exp4, 4, seqman ) );
724 
725  // erase sequence
726  CHECK_ERR( seqman.erase( &eh, 7, 7 ) );
727  EntityHandle exp5[][2] = { { 100, 104 }, { 108, 109 }, { 1001, 1001 } };
728  CHECK( seqman_equal( exp5, 3, seqman ) );
729 
730  // erase sequence
731  CHECK_ERR( seqman.erase( &eh, 108, 109 ) );
732  EntityHandle exp6[][2] = { { 100, 104 }, { 1001, 1001 } };
733  CHECK( seqman_equal( exp6, 2, seqman ) );
734 
735  // erase sequence
736  CHECK_ERR( seqman.erase( &eh, 100, 104 ) );
737  EntityHandle exp7[][2] = { { 1001, 1001 } };
738  CHECK( seqman_equal( exp7, 1, seqman ) );
739 
740  // erase sequence
741  CHECK_ERR( seqman.erase( &eh, 1001, 1001 ) );
742  CHECK( seqman.empty() );
743 }
744 
745 void test_find_free_handle()
746 {
747  bool append;
748  TypeSequenceManager::iterator seq;
749  TypeSequenceManager seqman;
750  make_basic_sequence( seqman ); // { [3,7], [100,111], [1001] }
751 
752  seq = seqman.find_free_handle( 0, MB_END_ID, append );
753  CHECK( seq != seqman.end() );
754  // expect the first available handle (2).
755  CHECK_EQUAL( (EntityHandle)3, ( *seq )->start_handle() );
756  CHECK_EQUAL( (EntityHandle)7, ( *seq )->end_handle() );
757  CHECK( !append );
758 
759  // Expect end() if no adjacent sequence
760  seq = seqman.find_free_handle( 9, 98, append );
761  CHECK( seq == seqman.end() );
762 
763  // Try a limited handle range
764  seq = seqman.find_free_handle( 8, 99, append );
765  CHECK( seq != seqman.end() );
766  // expect the first available handle (8).
767  CHECK_EQUAL( (EntityHandle)3, ( *seq )->start_handle() );
768  CHECK_EQUAL( (EntityHandle)7, ( *seq )->end_handle() );
769  CHECK( append );
770 
771  // Try an unambigious case (above tests have multiple
772  // possible answers, were we assume the first available
773  // handle).
774  seq = seqman.find_free_handle( 8, 98, append );
775  CHECK( seq != seqman.end() );
776  CHECK_EQUAL( (EntityHandle)3, ( *seq )->start_handle() );
777  CHECK_EQUAL( (EntityHandle)7, ( *seq )->end_handle() );
778  CHECK( append );
779 
780  // Try an unambigious case (above tests have multiple
781  // possible answers, were we assume the first available
782  // handle).
783  seq = seqman.find_free_handle( 9, 99, append );
784  CHECK( seq != seqman.end() );
785  CHECK_EQUAL( (EntityHandle)100, ( *seq )->start_handle() );
786  CHECK_EQUAL( (EntityHandle)111, ( *seq )->end_handle() );
787  CHECK( !append );
788 
789  // Try a case where the expected result handle
790  // is in the middle of the input range.
791  seq = seqman.find_free_handle( 900, 1100, append );
792  CHECK( seq != seqman.end() );
793  CHECK_EQUAL( (EntityHandle)1001, ( *seq )->start_handle() );
794  CHECK_EQUAL( (EntityHandle)1001, ( *seq )->end_handle() );
795  // Expect first available handle
796  CHECK( !append );
797 }
798 
799 void test_find_free_sequence()
800 {
801  EntityHandle start;
802  SequenceData* data = 0;
803  EntityID data_size = 0;
804  TypeSequenceManager seqman;
805  make_basic_sequence( seqman ); // { [3,7], [100,111], [1001] }
806  SequenceData* expdata = ( *seqman.begin() )->data();
807 
808  start = seqman.find_free_sequence( 2, 1, 3, data, data_size );
809  CHECK_EQUAL( expdata, data );
810  CHECK_EQUAL( (EntityHandle)1, start );
811 
812  start = seqman.find_free_sequence( 3, 1, 7, data, data_size );
813  CHECK_EQUAL( (EntityHandle)0, start );
814  CHECK_EQUAL( NULL, data );
815 
816  start = seqman.find_free_sequence( 30, 1, 120, data, data_size );
817  CHECK_EQUAL( expdata, data );
818  CHECK( start == 8 || start == 70 );
819 
820  start = seqman.find_free_sequence( 10, 92, 999, data, data_size );
821  CHECK_EQUAL( expdata, data );
822  CHECK_EQUAL( (EntityHandle)112, start );
823 
824  start = seqman.find_free_sequence( 100, 1, 600, data, data_size );
825  CHECK_EQUAL( expdata, data );
826  CHECK_EQUAL( (EntityHandle)112, start );
827 
828  start = seqman.find_free_sequence( 1000, 1, MB_END_ID, data, data_size );
829  CHECK_EQUAL( expdata, data );
830  CHECK_EQUAL( (EntityHandle)1002, start );
831 
832  start = seqman.find_free_sequence( 980, 1, 1800, data, data_size );
833  CHECK_EQUAL( (EntityHandle)0, start );
834  CHECK_EQUAL( NULL, data );
835 }
836 
837 void test_is_free_sequence()
838 {
839  SequenceData* data = 0;
840  TypeSequenceManager seqman;
841  make_basic_sequence( seqman ); // { [3,7], [100,111], [1001] }
842  SequenceData* expdata = ( *seqman.begin() )->data();
843 
844  CHECK( !seqman.is_free_sequence( 1, 3, data ) );
845  CHECK( seqman.is_free_sequence( 1, 2, data ) );
846  CHECK_EQUAL( expdata, data );
847  CHECK( !seqman.is_free_sequence( 7, 93, data ) );
848  CHECK( !seqman.is_free_sequence( 8, 93, data ) );
849  CHECK( seqman.is_free_sequence( 8, 92, data ) );
850  CHECK_EQUAL( expdata, data );
851  CHECK( !seqman.is_free_sequence( 111, 890, data ) );
852  CHECK( !seqman.is_free_sequence( 112, 890, data ) );
853  CHECK( seqman.is_free_sequence( 112, 879, data ) );
854  CHECK_EQUAL( expdata, data );
855  CHECK( seqman.is_free_sequence( 1002, 1, data ) );
856  CHECK_EQUAL( expdata, data );
857  CHECK( seqman.is_free_sequence( 2000, 20000, data ) );
858  CHECK_EQUAL( expdata, data );
859 }
860 
861 void test_is_free_handle()
862 {
863  // Construct a TypeSequenceManager with the following data:
864  // EntitySequence: |[1,500]| |[601,1000]| |[2500,2599]| |[2800,2999]|
865  // SequenceData: | [1,1000] | | [2001,3000] |
866  ErrorCode rval;
867  TypeSequenceManager seqman;
868  SequenceData* data1 = new SequenceData( 0, 1, 1000 );
869  SequenceData* data2 = new SequenceData( 0, 2001, 3000 );
870  rval = insert_seq( seqman, 1, 500, data1, true );CHECK_ERR( rval );
871  if( MB_SUCCESS != rval )
872  {
873  // data1 has been deleted by insert_seq call above
874  return;
875  }
876  rval = insert_seq( seqman, 601, 400, data1, false );CHECK_ERR( rval );
877  rval = insert_seq( seqman, 2500, 100, data2, true );CHECK_ERR( rval );
878  if( MB_SUCCESS != rval )
879  {
880  // data2 has been deleted by insert_seq call above
881  return;
882  }
883  rval = insert_seq( seqman, 2800, 200, data2, false );CHECK_ERR( rval );
884 
885  // Begin tests
886  TypeSequenceManager::iterator seq;
887  SequenceData* data;
888  EntityHandle first, last;
889 
890  // Test handle in use
891 
892  CHECK_EQUAL( MB_ALREADY_ALLOCATED, seqman.is_free_handle( 1, seq, data, first, last ) );
893  CHECK_EQUAL( MB_ALREADY_ALLOCATED, seqman.is_free_handle( 300, seq, data, first, last ) );
894  CHECK_EQUAL( MB_ALREADY_ALLOCATED, seqman.is_free_handle( 500, seq, data, first, last ) );
895  CHECK_EQUAL( MB_ALREADY_ALLOCATED, seqman.is_free_handle( 601, seq, data, first, last ) );
896  CHECK_EQUAL( MB_ALREADY_ALLOCATED, seqman.is_free_handle( 2500, seq, data, first, last ) );
897  CHECK_EQUAL( MB_ALREADY_ALLOCATED, seqman.is_free_handle( 2599, seq, data, first, last ) );
898  CHECK_EQUAL( MB_ALREADY_ALLOCATED, seqman.is_free_handle( 2800, seq, data, first, last ) );
899  CHECK_EQUAL( MB_ALREADY_ALLOCATED, seqman.is_free_handle( 2999, seq, data, first, last ) );
900 
901  // Test prepend to sequence
902 
903  seq = seqman.end();
904  data = 0;
905  first = last = 0;
906  CHECK( seqman.is_free_handle( 600, seq, data, first, last ) );
907  CHECK( seq != seqman.end() );
908  CHECK_EQUAL( (EntityHandle)601, ( *seq )->start_handle() );
909  CHECK_EQUAL( data1, data );
910  CHECK_EQUAL( (EntityHandle)600, first );
911  CHECK_EQUAL( (EntityHandle)600, last );
912 
913  seq = seqman.end();
914  data = 0;
915  first = last = 0;
916  CHECK( seqman.is_free_handle( 2499, seq, data, first, last ) );
917  CHECK( seq != seqman.end() );
918  CHECK_EQUAL( (EntityHandle)2500, ( *seq )->start_handle() );
919  CHECK_EQUAL( data2, data );
920  CHECK_EQUAL( (EntityHandle)2499, first );
921  CHECK_EQUAL( (EntityHandle)2499, last );
922 
923  seq = seqman.end();
924  data = 0;
925  first = last = 0;
926  CHECK( seqman.is_free_handle( 2799, seq, data, first, last ) );
927  CHECK( seq != seqman.end() );
928  CHECK_EQUAL( (EntityHandle)2800, ( *seq )->start_handle() );
929  CHECK_EQUAL( data2, data );
930  CHECK_EQUAL( (EntityHandle)2799, first );
931  CHECK_EQUAL( (EntityHandle)2799, last );
932 
933  // Test append to sequence
934 
935  seq = seqman.end();
936  data = 0;
937  first = last = 0;
938  CHECK( seqman.is_free_handle( 501, seq, data, first, last ) );
939  CHECK( seq != seqman.end() );
940  CHECK_EQUAL( (EntityHandle)1, ( *seq )->start_handle() );
941  CHECK_EQUAL( data1, data );
942  CHECK_EQUAL( (EntityHandle)501, first );
943  CHECK_EQUAL( (EntityHandle)501, last );
944 
945  seq = seqman.end();
946  data = 0;
947  first = last = 0;
948  CHECK( seqman.is_free_handle( 2600, seq, data, first, last ) );
949  CHECK( seq != seqman.end() );
950  CHECK_EQUAL( (EntityHandle)2500, ( *seq )->start_handle() );
951  CHECK_EQUAL( data2, data );
952  CHECK_EQUAL( (EntityHandle)2600, first );
953  CHECK_EQUAL( (EntityHandle)2600, last );
954 
955  seq = seqman.end();
956  data = 0;
957  first = last = 0;
958  CHECK( seqman.is_free_handle( 3000, seq, data, first, last ) );
959  CHECK( seq != seqman.end() );
960  CHECK_EQUAL( (EntityHandle)2800, ( *seq )->start_handle() );
961  CHECK_EQUAL( data2, data );
962  CHECK_EQUAL( (EntityHandle)3000, first );
963  CHECK_EQUAL( (EntityHandle)3000, last );
964 
965  // Test new sequence in existing SequenceData
966 
967  seq = seqman.end();
968  data = 0;
969  first = last = 0;
970  CHECK( seqman.is_free_handle( 502, seq, data, first, last ) );
971  CHECK( seqman.end() == seq );
972  CHECK_EQUAL( data1, data );
973  CHECK_EQUAL( (EntityHandle)501, first );
974  CHECK_EQUAL( (EntityHandle)600, last );
975 
976  seq = seqman.end();
977  data = 0;
978  first = last = 0;
979  CHECK( seqman.is_free_handle( 599, seq, data, first, last ) );
980  CHECK( seqman.end() == seq );
981  CHECK_EQUAL( data1, data );
982  CHECK_EQUAL( (EntityHandle)501, first );
983  CHECK_EQUAL( (EntityHandle)600, last );
984 
985  seq = seqman.end();
986  data = 0;
987  first = last = 0;
988  CHECK( seqman.is_free_handle( 2001, seq, data, first, last ) );
989  CHECK( seqman.end() == seq );
990  CHECK_EQUAL( data2, data );
991  CHECK_EQUAL( (EntityHandle)2001, first );
992  CHECK_EQUAL( (EntityHandle)2499, last );
993 
994  seq = seqman.end();
995  data = 0;
996  first = last = 0;
997  CHECK( seqman.is_free_handle( 2498, seq, data, first, last ) );
998  CHECK( seqman.end() == seq );
999  CHECK_EQUAL( data2, data );
1000  CHECK_EQUAL( (EntityHandle)2001, first );
1001  CHECK_EQUAL( (EntityHandle)2499, last );
1002 
1003  // Test new SequenceData
1004 
1005  seq = seqman.end();
1006  data = 0;
1007  first = last = 0;
1008  CHECK( seqman.is_free_handle( 1001, seq, data, first, last ) );
1009  CHECK( seqman.end() == seq );
1010  CHECK_EQUAL( (SequenceData*)0, data );
1011  CHECK_EQUAL( (EntityHandle)1001, first );
1012  CHECK_EQUAL( (EntityHandle)2000, last );
1013 
1014  seq = seqman.end();
1015  data = 0;
1016  first = last = 0;
1017  CHECK( seqman.is_free_handle( 1500, seq, data, first, last ) );
1018  CHECK( seqman.end() == seq );
1019  CHECK_EQUAL( (SequenceData*)0, data );
1020  CHECK_EQUAL( (EntityHandle)1001, first );
1021  CHECK_EQUAL( (EntityHandle)2000, last );
1022 
1023  seq = seqman.end();
1024  data = 0;
1025  first = last = 0;
1026  CHECK( seqman.is_free_handle( 2000, seq, data, first, last ) );
1027  CHECK( seqman.end() == seq );
1028  CHECK_EQUAL( (SequenceData*)0, data );
1029  CHECK_EQUAL( (EntityHandle)1001, first );
1030  CHECK_EQUAL( (EntityHandle)2000, last );
1031 
1032  seq = seqman.end();
1033  data = 0;
1034  first = last = 0;
1035  CHECK( seqman.is_free_handle( 3001, seq, data, first, last ) );
1036  CHECK( seqman.end() == seq );
1037  CHECK_EQUAL( (SequenceData*)0, data );
1038  CHECK_EQUAL( (EntityHandle)3001, first );
1039  CHECK_EQUAL( (EntityHandle)MB_END_ID, last );
1040 
1041  seq = seqman.end();
1042  data = 0;
1043  first = last = 0;
1044  CHECK( seqman.is_free_handle( 10000, seq, data, first, last ) );
1045  CHECK( seqman.end() == seq );
1046  CHECK_EQUAL( (SequenceData*)0, data );
1047  CHECK_EQUAL( (EntityHandle)3001, first );
1048  CHECK_EQUAL( (EntityHandle)MB_END_ID, last );
1049 }
1050 
1051 void call_find( TypeSequenceManager* seqman, const std::set< int >& removed, int num_orig_entities, int& n_failures )
1052 {
1053  ErrorCode rval = MB_SUCCESS;
1054 
1055  const EntitySequence* seq;
1056  int n_queries = 10000;
1057  for( int i = 0; i < n_queries; i++ )
1058  {
1059  long unsigned idx = ( (double)rand() / RAND_MAX * num_orig_entities ) + 1;
1060 
1061  // do not check for entities we've removed
1062  if( removed.count( idx ) != 0 ) continue;
1063  // search for this entity in the sequence manager
1064  rval = seqman->find( idx, seq );
1065  CHECK_EQUAL( MB_SUCCESS, rval );
1066  // check that the returned sequence actually contains this entity
1067  // (this is where threaded access used to fail)
1068  if( idx < seq->start_handle() || idx > seq->end_handle() )
1069  {
1070  n_failures += 1;
1071  }
1072  }
1073 }
1074 #ifndef MOAB_FORCE_32_BIT_HANDLES
1075 void test_threaded_access( int n_threads )
1076 {
1077  TypeSequenceManager seqman;
1078  std::set< int > removed_indices;
1079 
1080  // create a sequence from start to end
1081  EntityHandle start = 1, end = 200000;
1082  int i_end = end;
1083  SequenceData* data = new SequenceData( 0, start, end );CHECK_ERR( insert_seq( seqman, start, end, data ) );
1084 
1085  // erase one hundred random entities from the sequence
1086  // to ensure a lot of switching of TypeSequenceManager::lastReferenced
1087  Error e;
1088  for( int i = 0; i < 100; i++ )
1089  {
1090  int idx = ( (double)rand() / RAND_MAX * i_end ) + 1;
1091  removed_indices.insert( idx );
1092  seqman.erase( &e, idx );
1093  }
1094  // create a set of quereies per thread
1095  std::vector< std::thread > threads;
1096  std::vector< int > failures( n_threads, 0 );
1097  for( int i = 0; i < n_threads; i++ )
1098  {
1099  threads.push_back( std::thread( call_find, &seqman, removed_indices, i_end, std::ref< int >( failures[i] ) ) );
1100  }
1101  // wait for threads to finish
1102  for( size_t i = 0; i < threads.size(); i++ )
1103  {
1104  threads[i].join();
1105  }
1106 
1107  int n_failures = 0;
1108  for( size_t i = 0; i < failures.size(); i++ )
1109  n_failures += failures[i];
1110 
1111  if( n_failures > 0 )
1112  {
1113  std::cout << n_failures << " invalid sequences found." << std::endl;
1114  }
1115 
1116  CHECK_EQUAL( 0, n_failures );
1117 }
1118 
1119 void test_single_thread_access()
1120 {
1121  test_threaded_access( 1 );
1122 }
1123 
1124 void test_multi_thread_access()
1125 {
1126  test_threaded_access( 2 );
1127 }
1128 #endif
1129 // Regression test for bug fixed in SVN revision 1952.
1130 // SVN checkin message:
1131 // Fixing a bug in allocation of sequences. Before this commit, when:
1132 // - Existing sequence starts at one place, e.g. 41686, but its
1133 // sequenceData starts earlier, e.g. 41673, and
1134 // - You try to allocate a new sequence at a lower handle but with a
1135 // range which is more than the room available in the sequenceData,
1136 //
1137 // then
1138 // - the code wants to allocate right up against the lower end of the
1139 // existing sequence, and sizes the new sequenceData accordingly
1140 // (i.e. with a max of 41685).
1141 //
1142 // In this case, that new sequenceData will overlap the existing
1143 // sequenceData (which starts at 41673, even though it has an empty chunk
1144 // in front).
1145 //
1146 // So, this change passes back a sequence data size from the code which
1147 // computes where to put the start handle when allocating the new
1148 // sequence.
1149 void regression_svn1952()
1150 {
1151  const EntityHandle last_handle = 50000;
1152  TypeSequenceManager seqman;
1153  SequenceData* data = new SequenceData( 0, 41673, last_handle );CHECK_ERR( insert_seq( seqman, 41686, 1000, data, true ) );
1154 
1155  SequenceData* result_data;
1156  EntityID result_size;
1157  EntityHandle result_handle;
1158  result_handle = seqman.find_free_sequence( 1686, 4000, 2 * last_handle, result_data, result_size );
1159  CHECK( result_handle > last_handle || result_handle + result_size <= 41673 );
1160  CHECK( result_handle + result_size <= 2 * last_handle );
1161 }
1162 
1163 // Regression test for bug fixed in SVN revision 1958.
1164 // SVN checkin message:
1165 // Another fix to SequenceManager. This time:
1166 // - there was no sequence data allocated for the target range
1167 // - there was exactly enough room in unallocated sequence data for the target range
1168 // - the next data sequence up had a couple of empty slots, so the first occupied handle was a
1169 // couple spaces from the start of the sequence data
1170 // - the upper end of the range of the allocated sequence data was computed based on the first
1171 // handle in the next sequence data
1172 //
1173 // Fixed by setting the size using the parameter I added before.
1174 void regression_svn1958()
1175 {
1176  const int data_size = 100;
1177  const EntityHandle data_start = 100;
1178  const EntityHandle data_end = data_start + data_size - 1;
1179  const int seq_offset = 2;
1180 
1181  TypeSequenceManager seqman;
1182  SequenceData* data = new SequenceData( 0, data_start, data_end );CHECK_ERR( insert_seq( seqman, data_start + seq_offset, data_size - seq_offset, data, true ) );
1183 
1184  SequenceData* result_data;
1185  EntityID result_size;
1186  EntityHandle result_handle;
1187  result_handle = seqman.find_free_sequence( data_start - 1, 1, 100000, result_data, result_size );
1188  CHECK( result_handle > data_end || result_handle + result_size <= data_start );
1189 }
1190 
1191 // Regression test for bug fixed in SVN revision 1960.
1192 // SVN checkin message:
1193 // Third time pays for all. This time, in TSM::is_free_sequence was true,
1194 // so there was a free sequence; SM::create_entity_sequence then called
1195 // SM::new_sequence_size, which used the first handle of the next higher
1196 // sequence to compute the size, when the start handle of the data on
1197 // which that first handle was allocated was smaller. Sigh.
1198 void regression_svn1960()
1199 {
1200  const int data_size = 6000;
1201  const EntityHandle data_start = 4000;
1202  const EntityHandle data_end = data_start + data_size - 1;
1203  const int seq_offset = 1000;
1204 
1205  TypeSequenceManager seqman;
1206  SequenceData* data = new SequenceData( 0, data_start, data_end );CHECK_ERR( insert_seq( seqman, data_start + seq_offset, data_size - seq_offset, data, true ) );
1207 
1208  SequenceData* result_data;
1209  EntityID result_size;
1210  EntityHandle result_handle;
1211  result_handle = seqman.find_free_sequence( data_start - 2, 1, 100000, result_data, result_size );
1212  CHECK( result_handle + result_size <= data_start );
1213 }