92 if( failures ) std::cerr <<
"<<<< " << failures <<
" TESTS FAILED >>>>" << std::endl;
126 const void* some_values,
128 const void* default_value,
130 bool get_by_pointer =
false );
138 const void* default_value,
139 int default_value_length );
142 const char* tag_name,
193 exp_bytes = num_vals *
sizeof( int );
196 exp_bytes = num_vals *
sizeof( double );
205 exp_bytes = num_vals;
210 std::vector< unsigned char > defv( bytes );
215 CHECK( !memcmp( defval, &defv[0], bytes ) );
300 unsigned char defval[] = { 1, 2, 3, 4, 0, 0, 0, 0 };
312 double defval2[] = { 3.14159, 2.71828 };
320 unsigned char def_bit_val = 0xBF;
327 unsigned char defval[] = { 1, 2, 3, 4, 0, 0, 0, 0 };
330 const void* defptr = defval;
340 double defval2[] = { 3.14159, 2.71828 };
352 static void concat_to_list(
const void* concat, std::vector< const void* >& list,
size_t bytes )
354 const unsigned char* ptr =
reinterpret_cast< const unsigned char*
>( concat );
355 std::vector< const void* >::iterator iter = list.begin();
356 for( ; iter != list.end(); ++iter, ptr += bytes )
365 const void* some_values,
367 const void* default_value,
369 bool get_by_pointer )
371 std::vector< unsigned char > data;
388 bytes = vals_per_ent *
sizeof( int );
391 bytes = vals_per_ent *
sizeof( double );
400 bytes = vals_per_ent;
415 std::vector< EntityHandle > handle_list;
418 if( i->first == i->second || i->second - i->first == 1 )
427 handle_list.push_back( mid );
428 handle_range.
insert( mid + 1, i->second );
432 for(
unsigned i = 0; i < handle_list.size(); ++i )
437 std::vector< const void* > list( 1 );
444 list[0] = some_values;
452 data.resize( bytes );
462 CHECK( !memcmp( some_values, list[0], bytes ) );
467 CHECK( !memcmp( some_values, &data[0], bytes ) );
472 const int step = std::min( (
int)handle_list.size(), num_values );
473 data.resize( step * bytes );
474 for(
int i = 0; i < (int)handle_list.size(); i += step )
476 const int n = std::min( (
int)handle_list.size() - i, step );
496 std::vector< int > rsizes( n, 0 );
498 for(
int j = 0; j < n; ++j )
512 const unsigned char* ptr =
reinterpret_cast< const unsigned char*
>( some_values );
513 for(
int j = 0; j < n; ++j, ptr += bytes )
514 CHECK( !memcmp( ptr, list[j], bytes ) );
522 std::vector< unsigned char > input_data( handle_range.
size() * bytes );
523 for(
int i = 0; i < (int)input_data.size(); i += num_values * bytes )
524 memcpy( &input_data[i], some_values, std::min( (
int)input_data.size() - i, num_values * bytes ) );
529 list.resize( num_values );
531 while( list.size() < handle_range.
size() )
533 size_t s = list.size();
534 list.resize( 2 * s );
535 std::copy( list.begin(), list.begin() + s, list.begin() + s );
547 list.resize( handle_range.
size(), 0 );
551 std::vector< int > rsizes( handle_range.
size(), 0 );
553 for(
size_t j = 0; j < handle_range.
size(); ++j )
557 list.resize( handle_range.
size(), 0 );
562 data.resize( handle_range.
size() * bytes );
569 const bool dstep = ( set_mode !=
ONE_VALUE );
570 for(
size_t i = 0; i < list.size(); ++i )
572 CHECK( list[i * dstep] != NULL );
573 const void* ptr =
reinterpret_cast< const char*
>( some_values ) + ( i % num_values ) * bytes;
574 CHECK( !memcmp( list[i * dstep], ptr, bytes ) );
586 data.clear(), data.resize(
entities.size() * bytes,
'\001' );
594 for(
unsigned i = 0; i <
entities.size(); ++i )
595 CHECK( !memcmp( default_value, list[i], bytes ) );
602 std::vector< unsigned char > zeros( bytes, 0 );
603 for(
unsigned i = 0; i <
entities.size(); ++i )
604 CHECK( !memcmp( &zeros[0], list[i], bytes ) );
615 data.resize( bytes );
617 CHECK( !memcmp( some_values, &data[0], bytes ) );
620 data.resize( step * bytes );
621 for(
int i = 0; i < (int)handle_list.size(); i += step )
623 const int n = std::min( (
int)handle_list.size() - i, step );
625 CHECK( !memcmp( some_values, &data[0], step * bytes ) );
631 list.resize( handle_range.
size(), 0 );
633 for(
size_t i = 0; i < handle_range.
size(); ++i )
635 const void* ptr =
reinterpret_cast< const char*
>( some_values ) + ( i % num_values ) * bytes;
636 CHECK( !memcmp( ptr, list[i], bytes ) );
642 const int data[] = { 21, 00, 46, 30, 26, 63, 05, 49, 31, 39, 86, 77, 24, 37, 25, 98,
643 26, 20, 01, 54, 16, 28, 55, 49, 96, 18, 28, 18, 53, 00, 80, 48 };
644 const int num_val =
sizeof( data ) /
sizeof( data[0] );
648 const int defaultval = 19740508;
654 const int data[] = { 231, 416, 294, 504, 318, 558, 494, 006, 464, 648, 737, 045, 179, 852, 944, 336,
655 773, 248, 434, 615, 677, 667, 521, 748, 820, 533, 955, 300, 108, 726, 747, 597 };
656 const int num_val =
sizeof( data ) /
sizeof( data[0] );
660 const int defaultval[] = { 5, 8, 1974 };
666 const double pi = 3.1415926535897931;
667 const double e = 2.7182818284590451;
668 const double data[] = { 1, 1., pi, e, 2, 1. / 2, 2 * pi, e / 2, 3, 1. / 3,
669 3 * pi, e / 3, 4, 1. / 4, 4 * pi, e / 4, 5, 1. / 5, 5 * pi, e / 5,
670 6, 1. / 6, 6 * pi, e / 6, 0, 100, 1000, 10000 };
671 const int num_val =
sizeof( data ) /
sizeof( data[0] );
675 const double defaultval[] = { 0.11, 0.22 };
681 const double data[] = { 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 16 };
682 const int num_val =
sizeof( data ) /
sizeof( data[0] );
686 const double defaultval[] = { -1, -2 };
692 const unsigned char data[] =
"a few aribtrary bytes entered as a string";
693 const int num_val =
sizeof( data ) /
sizeof( data[0] );
697 const unsigned char defaultval[] =
"XY";
703 const double data[] = { 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 16 };
704 const int num_val =
sizeof( data ) /
sizeof( data[0] );
708 const double defaultval[] = { -1, -2 };
715 const unsigned char data[] =
"a few aribtrary bytes entered as a string";
716 const int num_val =
sizeof( data ) /
sizeof( data[0] );
720 const unsigned char defaultval[] =
"XY";
724 const double dbldata[3] = { 1.0, 2.0, 3.0 };
725 const int dbl_num_val =
sizeof( dbldata ) /
sizeof(
double );
729 const double dbldefaultval[3] = { 0.0, 0.0, 0.0 };
736 const int int_val = 0xcab;
739 const double dbl_val[] = { 3.14159, -3.14159 };
740 const double default_val[] = { -2, 5 };
746 const int int_val = 0xcab;
749 const double dbl_val[] = { 3.14159, -3.14159 };
750 const double default_val[] = { -2, 5 };
768 unsigned counter = 0;
772 unsigned char bits = (
unsigned char)( rand() & 3 );
774 unsigned char bits_out = 0;
780 unsigned char defval =
'\003';
781 unsigned char zero =
'\0';
821 const unsigned char bits = 2;
827 unsigned char bits_out = 0;
853 int values[5] = { 1, 2, 3, 4, 5 };
855 const void*
const valarr[1] = { 0 };
859 const int num_in_set = 3;
939 int values[5] = { 0xBEEF, 0xBEEF, 0xBEEF, 0xBEEF, 0xBEEF };
941 const void*
const valarr[1] = { values };
945 const int num_in_set = 3;
992 const int def_val = 0xABCD;
993 const int fill_val = 0xBEEF;
994 const int find_val = 0xFEED;
998 Range elements, vertices, results;
1009 *( elements.
begin() += 2 * elements.
size() / 4 ),
1010 *( elements.
begin() += 3 * elements.
size() / 4 ) };
1011 int values[3] = { find_val, find_val, find_val };
1015 const void*
const findarr[1] = { &find_val };
1030 results.
erase( arr[1] );
1038 const void*
const defarr[1] = { &def_val };
1042 Range expected( elements );
1043 expected.
erase( arr[0] );
1044 expected.
erase( arr[1] );
1045 expected.
erase( arr[2] );
1046 CHECK( expected == results );
1050 const char* tag_name,
1059 unsigned memcmp_size = tag_size;
1063 memcmp_size =
sizeof( double );
1065 memcmp_size =
sizeof( int );
1070 std::vector< unsigned char > bytes( memcmp_size, 0 );
1072 CHECK( !memcmp( value, &bytes[0], memcmp_size ) );
1075 std::string name2( tag_name );
1079 bytes.resize( memcmp_size, 0 );
1081 CHECK( !memcmp( value, &bytes[0], memcmp_size ) );
1097 unsigned char bits =
'\002';
1110 int default_val = 42;
1111 const char*
tagname =
"dead_tag";
1158 std::vector< Tag > tags;
1160 CHECK( std::find( tags.begin(), tags.end(), tag ) == tags.end() );
1165 CHECK( std::find( tags.begin(), tags.end(), tag ) == tags.end() );
1172 template <
typename Container >
1176 data.resize( handles.size() );
1177 std::vector< unsigned char >::const_iterator j = data.begin();
1178 for(
typename Container::const_iterator i = handles.begin(); i != handles.end(); ++i, ++j )
1187 return std::find( list.begin(), list.end(), tag ) != list.end();
1220 Tag sparse, dense, bit;
1226 EntityHandle sparse_ents[4] = { sparse_ent, sparse_dense_ent, sparse_bit_ent, all_tag_ent };
1227 EntityHandle dense_ents[4] = { dense_ent, sparse_dense_ent, dense_bit_ent, all_tag_ent };
1228 EntityHandle bit_ents[4] = { bit_ent, sparse_bit_ent, dense_bit_ent, all_tag_ent };
1229 int values[4] = { -1, -2, -3, -4 };
1232 for(
int j = 0; j < 4; ++j )
1234 unsigned char bitval = 0xF;
1239 std::vector< Tag > sparse_ent_tags, dense_ent_tags, bit_ent_tags, sparse_dense_ent_tags, sparse_bit_ent_tags,
1240 dense_bit_ent_tags, all_tag_ent_tags, no_tag_ent_tags;
1308 Range all_entities, del1_range, keep_range;
1309 std::vector< EntityHandle > del1_list, del2_list, keep_list;
1323 del2_list.push_back( *i );
1327 del1_list.resize( del1_range.
size() );
1328 std::copy( del1_range.
begin(), del1_range.
end(), del1_list.begin() );
1329 keep_list.resize( keep_range.
size() );
1330 std::copy( keep_range.
begin(), keep_range.
end(), keep_list.begin() );
1335 const char*
tagname =
"dead_tag";
1348 std::vector< EntityHandle > tag_data( keep_range.
size(), 0 );
1350 CHECK( tag_data == keep_list );
1357 if( with_default_value )
1360 std::vector< EntityHandle > expected( del1_range.
size(), *defval );
1361 CHECK( expected == tag_data );
1368 std::vector< EntityHandle > expected( del1_range.
size(), 0 );
1369 CHECK( expected == tag_data );
1377 if( with_default_value )
1380 std::vector< EntityHandle > expected( del1_range.
size(), *defval );
1381 CHECK( expected == tag_data );
1388 std::vector< EntityHandle > expected( del1_range.
size(), 0 );
1389 CHECK( expected == tag_data );
1419 unsigned char defval =
'\006';
1425 unsigned char val =
'\001';
1451 const void** values,
1454 const void* default_value,
1455 int default_value_length )
1457 std::vector< const void* > data;
1458 std::vector< int > data_lens;
1482 std::vector< EntityHandle > handle_list;
1485 if( i->first == i->second || i->second - i->first == 1 )
1494 handle_list.push_back( mid );
1495 handle_range.
insert( mid + 1, i->second );
1499 for(
unsigned i = 0; i < handle_list.size(); ++i )
1503 if( num_values == 1 )
1507 const void* data_ptr;
1511 CHECK( !memcmp( values[0], data_ptr, data_len ) );
1517 typesize =
sizeof( int );
1520 typesize =
sizeof( double );
1536 if( num_values == 1 )
1538 count = handle_list.size();
1540 rval =
mb.
tag_clear_data( tag, &handle_list[0], count, values[0], lengths[0] );
1544 count = std::min( (
int)handle_list.size(), num_values );
1550 data.resize( count, 0 );
1552 data_lens.resize( count, 0 );
1554 for(
int i = 0; i < count; ++i )
1557 CHECK( NULL != data[i] );
1558 CHECK( !memcmp( values[i], data[i * step], typesize * lengths[i * step] ) );
1563 if( num_values > 1 )
1565 data.resize( num_values );
1566 data_lens.resize( num_values );
1567 std::copy( values, values + num_values, data.begin() );
1568 std::copy( lengths, lengths + num_values, data_lens.begin() );
1569 while( data.size() < handle_range.
size() )
1571 size_t s = data.size();
1572 data.resize( 2 * s );
1573 std::copy( data.begin(), data.begin() + s, data.begin() + s );
1574 data_lens.resize( 2 * s );
1575 std::copy( data_lens.begin(), data_lens.begin() + s, data_lens.begin() + s );
1586 data.resize( handle_range.
size(), 0 );
1588 data_lens.resize( handle_range.
size(), 0 );
1591 for(
size_t i = 0; i < data.size(); ++i )
1593 const void* expect = values[( i * step ) % num_values];
1594 int expect_len = lengths[( i * step ) % num_values];
1596 CHECK( NULL != data[i] );
1597 CHECK( !memcmp( expect, data[i], expect_len * typesize ) );
1603 data_lens.resize(
entities.size() );
1609 for(
unsigned i = 0; i <
entities.size(); ++i )
1611 CHECK_EQUAL( default_value_length, data_lens[i] );
1612 CHECK( NULL != data[i] );
1613 CHECK( !memcmp( default_value, data[i], typesize * default_value_length ) );
1627 CHECK( !memcmp( values[0], data_ptr, typesize * data_len ) );
1630 count = std::min( (
int)handle_list.size(), num_values );
1632 data.resize( count, 0 );
1634 data_lens.resize( count, 0 );
1636 for(
int i = 0; i < count; ++i )
1639 CHECK( NULL != data[i] );
1640 CHECK( !memcmp( values[i], data[i], typesize * lengths[i] ) );
1645 data.resize( handle_range.
size(), 0 );
1647 data_lens.resize( handle_range.
size(), 0 );
1650 for(
size_t i = 0; i < data.size(); ++i )
1652 const void* expect = values[i % num_values];
1653 int expect_len = lengths[i % num_values];
1655 CHECK( NULL != data[i] );
1656 CHECK( !memcmp( expect, data[i], typesize * expect_len ) );
1662 const double doubles[14] = { 1, 2, 3, 4, -4, -3, -2, -1, 42, 0, 1974, -0.5, 1. / 3, -1e-10 };
1663 const void* dvals[5] = { doubles, doubles + 3, doubles + 4, doubles + 8, doubles + 10 };
1664 const int dlens[5] = { 3, 1, 4, 2, 4 };
1667 const int ints[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1668 -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15 };
1671 const int ilens[9] = { 1, 2, 9, 5, 4, 7, 1, 2, 1 };
1672 const int defvals[] = { 42, 5, 8, 74 };
1678 const double doubles[14] = { 1, 2, 3, 4, -4, -3, -2, -1, 42, 0, 1974, -0.5, 1. / 3, -1e-10 };
1679 const void* dvals[5] = { doubles, doubles + 3, doubles + 4, doubles + 8, doubles + 10 };
1680 const int dlens[5] = { 3, 1, 4, 2, 4 };
1683 const int ints[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1684 -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15 };
1687 const int ilens[9] = { 1, 2, 9, 5, 4, 7, 1, 2, 1 };
1688 const int defvals[] = { 42, 5, 8, 74 };
1699 int values1[] = { 6 };
1700 int values5[] = { 1, 2, 3, 4, 5 };
1703 const void* data[1];
1711 CHECK_EQUAL( values1[0], *
reinterpret_cast< const int*
>( data[0] ) );
1719 CHECK_EQUAL( values5[0],
reinterpret_cast< const int*
>( data[0] )[0] );
1720 CHECK_EQUAL( values5[1],
reinterpret_cast< const int*
>( data[0] )[1] );
1721 CHECK_EQUAL( values5[2],
reinterpret_cast< const int*
>( data[0] )[2] );
1722 CHECK_EQUAL( values5[3],
reinterpret_cast< const int*
>( data[0] )[3] );
1723 CHECK_EQUAL( values5[4],
reinterpret_cast< const int*
>( data[0] )[4] );
1728 const double doubles[3] = { 1e-1, 1e-2, 1e-3 };
1729 const void* dvals[] = { doubles };
1730 const int dlen =
sizeof( doubles ) /
sizeof(
double );
1733 const int ints[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1734 -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15 };
1735 const void* ivals[] = {
ints };
1736 const int ilen =
sizeof(
ints ) /
sizeof(
int );
1737 const int defvals[] = { 42, 5, 8, 74 };
1759 std::vector< double > coords( 90, 0.0 );
1778 int default_sparse = 5;
1780 std::vector< int > sparse_vals( sets[0].
size(), -1 );
1785 const void* ptrs[] = { &default_sparse };
1790 double default_dense = -1.0;
1792 std::vector< double > dense_vals( sets[1].
size(), 3.14159 );
1797 ptrs[0] = &default_dense;
1813 result.
insert( sets[1].front() );
1814 ptrs[0] = &default_sparse;
1822 ptrs[0] = &default_sparse;
1832 const size_t NUM_VTX = 30000;
1835 std::vector< double > coords( 3 * NUM_VTX, 0.0 );
1843 std::vector< unsigned char > values( NUM_VTX );
1844 std::vector< unsigned char >::iterator it = values.begin();
1846 *it = (
unsigned char)( *j & 0xF );
1850 std::vector< unsigned char > values2( NUM_VTX, 0 );
1855 it = values.begin();
1864 unsigned char value = 0xC;
1865 Range expected, results;
1867 if( (
unsigned char)( *j & 0xF ) == value ) expected.
insert( *j );
1868 const void* vals[] = { &value };
1876 values.resize( NUM_VTX,
'\001' );
1893 size_t first_one = std::find( values.begin(), values.end(),
'\001' ) - values.begin();
1899 Range vertex_handles;
1900 const double vertex_coords[] = { 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 1, 0, 1, 1, 0, 2, 1, 0, 0, 2, 0, 1, 2, 0, 2, 2, 0,
1902 0, 0, 1, 1, 0, 1, 2, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 1, 0, 2, 1, 1, 2, 1, 2, 2, 1,
1904 0, 0, 2, 1, 0, 2, 2, 0, 2, 0, 1, 2, 1, 1, 2, 2, 1, 2, 0, 2, 2, 1, 2, 2, 2, 2, 2 };
1905 const unsigned num_vtx =
sizeof(
vertex_coords ) / ( 3 *
sizeof(
double ) );
1911 EntityHandle conn[8][8] = { { 0, 1, 4, 3, 9, 10, 13, 12 }, { 1, 2, 5, 4, 10, 11, 14, 13 },
1912 { 3, 4, 7, 6, 12, 13, 16, 15 }, { 4, 5, 8, 7, 13, 14, 17, 16 },
1913 { 9, 10, 13, 12, 18, 19, 22, 21 }, { 10, 11, 14, 13, 19, 20, 23, 22 },
1914 { 12, 13, 16, 15, 21, 22, 25, 24 }, { 13, 14, 17, 16, 22, 23, 26, 25 } };
1915 for(
unsigned i = 0; i < 8; ++i )
1940 const double coords[] = { 0, 0, 0 };
1947 const void* ptrarr[1] = { &taglen };
1964 const int tagval = 0xdeadbeef;
1965 const void* valarr[1] = { &tagval };
1966 const int numval = 1;
1969 Tag dense, sparse, bit;
1978 handles.
insert( handle );
1980 rval =
moab.tag_set_data( dense, &handle, 1, &tagval );
1982 rval =
moab.tag_set_data( sparse, &handle, 1, &tagval );
1984 rval =
moab.tag_set_data( bit, &handle, 1, &tagval );
1987 rval =
moab.tag_set_data( dense, handles, &tagval );
1989 rval =
moab.tag_set_data( sparse, handles, &tagval );
1991 rval =
moab.tag_set_data( bit, handles, &tagval );
1994 rval =
moab.tag_set_by_ptr( dense, &handle, 1, valarr, &numval );
1996 rval =
moab.tag_set_by_ptr( sparse, &handle, 1, valarr, &numval );
1999 rval =
moab.tag_set_by_ptr( dense, handles, valarr, &numval );
2001 rval =
moab.tag_set_by_ptr( sparse, handles, valarr, &numval );
2010 handles.
insert( handle );
2012 rval =
moab.tag_set_data( dense, &handle, 1, &tagval );
2014 rval =
moab.tag_set_data( sparse, &handle, 1, &tagval );
2016 rval =
moab.tag_set_data( bit, &handle, 1, &tagval );
2019 rval =
moab.tag_set_data( dense, handles, &tagval );
2021 rval =
moab.tag_set_data( sparse, handles, &tagval );
2023 rval =
moab.tag_set_data( bit, handles, &tagval );
2026 rval =
moab.tag_set_by_ptr( dense, &handle, 1, valarr, &numval );
2028 rval =
moab.tag_set_by_ptr( sparse, &handle, 1, valarr, &numval );
2031 rval =
moab.tag_set_by_ptr( dense, handles, valarr, &numval );
2033 rval =
moab.tag_set_by_ptr( sparse, handles, valarr, &numval );
2040 const int NUM_VTX = 1000;
2043 std::vector< double > coords( 3 * NUM_VTX );
2048 const int step = 100;
2049 int remaining = NUM_VTX;
2051 for(
int j = 0; j < remaining; j += step )
2055 i = verts.
erase( i );
2062 verts.
erase( verts.
begin() + ( step - 5 ), verts.
begin() + ( step + 5 ) );
2066 const int defval = 0;
2070 std::vector< int > values( verts.
size(), defval );
2073 for(
size_t j = 0; j < values.size(); ++j )
2081 int count, total = 0;
2082 while( i != verts.
end() )
2087 assert( total + count <= (
int)verts.
size() );
2090 if( i == verts.
begin() && with_default && storage ==
MB_TAG_SPARSE ) ( (
int*)ptr )[0] = 1.0;
2098 while( i != verts.
end() )
2104 int* arr =
reinterpret_cast< int*
>( ptr );
2107 *arr =
static_cast< int >( ( *i ) % NUM_VTX );
2115 while( i != verts.
end() )
2121 int* arr =
reinterpret_cast< int*
>( ptr );
2124 CHECK_EQUAL( *arr,
static_cast< int >( ( *i ) % NUM_VTX ) );
2154 const int NUM_VTX = 1000;
2157 std::vector< double > coords( 3 * NUM_VTX );