|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
#include "moab/Core.hpp"#include "moab/Range.hpp"#include "TestUtil.hpp"#include <cstdlib>#include <algorithm>
Include dependency graph for TagTest.cpp:Go to the source code of this file.
| enum SetMode |
Definition at line 115 of file TagTest.cpp.
| static void concat_to_list | ( | const void * | concat, |
| std::vector< const void * > & | list, | ||
| size_t | bytes | ||
| ) | [static] |
Definition at line 352 of file TagTest.cpp.
Referenced by test_get_set().
{
const unsigned char* ptr = reinterpret_cast< const unsigned char* >( concat );
std::vector< const void* >::iterator iter = list.begin();
for( ; iter != list.end(); ++iter, ptr += bytes )
*iter = ptr;
}
| static bool contains_tag | ( | Tag | tag, |
| const std::vector< Tag > & | list | ||
| ) | [static] |
Definition at line 1185 of file TagTest.cpp.
Referenced by test_get_entity_tags().
{
return std::find( list.begin(), list.end(), tag ) != list.end();
}
| int main | ( | ) |
Definition at line 49 of file TagTest.cpp.
References regression_one_entity_by_var_tag(), regression_tag_on_nonexistent_entity(), RUN_TEST, test_bit_tag_big(), test_clear_bit(), test_clear_dense(), test_clear_dense_varlen(), test_clear_sparse(), test_clear_sparse_varlen(), test_create_tag(), test_create_variable_length_tag(), test_delete_bit_data(), test_delete_dense_data(), test_delete_dense_tag(), test_delete_mesh_tag(), test_delete_sparse_data(), test_delete_sparse_tag(), test_get_by_tag(), test_get_by_tag_value(), test_get_by_tag_value_dense(), test_get_entity_tags(), test_get_ents_with_default_value(), test_get_pointers_dense(), test_get_pointers_sparse(), test_get_set_bit(), test_get_set_dense_double(), test_get_set_dense_int(), test_get_set_sparse_int(), test_get_set_variable_length_dense(), test_get_set_variable_length_mesh(), test_get_set_variable_length_sparse(), test_mesh_value(), test_set_pointers_dense(), test_set_pointers_sparse(), test_tag_iterate_dense(), test_tag_iterate_dense_default(), test_tag_iterate_invalid(), test_tag_iterate_sparse(), and test_tag_iterate_sparse_default().
{
int failures = 0;
failures += RUN_TEST( test_create_tag );
failures += RUN_TEST( test_get_set_sparse_int );
failures += RUN_TEST( test_get_set_dense_int );
failures += RUN_TEST( test_get_set_dense_double );
failures += RUN_TEST( test_get_set_bit );
failures += RUN_TEST( test_get_by_tag );
failures += RUN_TEST( test_get_by_tag_value );
failures += RUN_TEST( test_get_by_tag_value_dense );
failures += RUN_TEST( test_mesh_value );
failures += RUN_TEST( test_get_pointers_sparse );
failures += RUN_TEST( test_get_pointers_dense );
failures += RUN_TEST( test_set_pointers_sparse );
failures += RUN_TEST( test_set_pointers_dense );
failures += RUN_TEST( test_get_entity_tags );
failures += RUN_TEST( test_delete_sparse_tag );
failures += RUN_TEST( test_delete_dense_tag );
failures += RUN_TEST( test_delete_mesh_tag );
failures += RUN_TEST( test_delete_sparse_data );
failures += RUN_TEST( test_delete_dense_data );
failures += RUN_TEST( test_delete_bit_data );
failures += RUN_TEST( test_create_variable_length_tag );
failures += RUN_TEST( test_get_set_variable_length_sparse );
failures += RUN_TEST( test_get_set_variable_length_dense );
failures += RUN_TEST( test_get_set_variable_length_mesh );
failures += RUN_TEST( test_get_ents_with_default_value );
failures += RUN_TEST( test_bit_tag_big );
failures += RUN_TEST( regression_one_entity_by_var_tag );
failures += RUN_TEST( regression_tag_on_nonexistent_entity );
failures += RUN_TEST( test_clear_dense );
failures += RUN_TEST( test_clear_sparse );
failures += RUN_TEST( test_clear_bit );
failures += RUN_TEST( test_clear_dense_varlen );
failures += RUN_TEST( test_clear_sparse_varlen );
failures += RUN_TEST( test_tag_iterate_sparse );
failures += RUN_TEST( test_tag_iterate_dense );
failures += RUN_TEST( test_tag_iterate_sparse_default );
failures += RUN_TEST( test_tag_iterate_dense_default );
failures += RUN_TEST( test_tag_iterate_invalid );
if( failures ) std::cerr << "<<<< " << failures << " TESTS FAILED >>>>" << std::endl;
return failures;
}
| void regression_one_entity_by_var_tag | ( | ) |
Definition at line 1934 of file TagTest.cpp.
References CHECK_EQUAL, CHECK_ERR, moab::Core::create_vertex(), ErrorCode, moab::Range::front(), moab::Core::get_entities_by_type_and_tag(), MB_TAG_DENSE, MB_TAG_EXCL, MB_TAG_VARLEN, MB_TYPE_INTEGER, MBVERTEX, moab::Range::size(), moab::Core::tag_get_handle(), and moab::Core::tag_set_by_ptr().
Referenced by main().
{
Core moab;
ErrorCode rval;
EntityHandle vertex;
const double coords[] = { 0, 0, 0 };
rval = moab.create_vertex( coords, vertex );CHECK_ERR( rval );
Tag tag;
rval = moab.tag_get_handle( "testtag", 0, MB_TYPE_INTEGER, tag, MB_TAG_DENSE | MB_TAG_VARLEN | MB_TAG_EXCL );CHECK_ERR( rval );
int taglen = 1;
const void* ptrarr[1] = { &taglen };
rval = moab.tag_set_by_ptr( tag, &vertex, 1, ptrarr, &taglen );CHECK_ERR( rval );
Range ents;
rval = moab.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, 0, 1, ents );CHECK_ERR( rval );
CHECK_EQUAL( (size_t)1, ents.size() );
CHECK_EQUAL( vertex, ents.front() );
}
| void regression_tag_on_nonexistent_entity | ( | ) |
Definition at line 1960 of file TagTest.cpp.
References CHECK_EQUAL, CHECK_ERR, moab::Range::clear(), moab::Core::create_meshset(), ErrorCode, moab::Range::insert(), MB_ENTITY_NOT_FOUND, MB_TAG_DENSE, MB_TAG_EXCL, MB_TAG_SPARSE, MB_TYPE_BIT, MB_TYPE_INTEGER, moab::Core::tag_get_handle(), moab::Core::tag_set_by_ptr(), and moab::Core::tag_set_data().
Referenced by main().
{
Core moab;
ErrorCode rval;
const int tagval = 0xdeadbeef;
const void* valarr[1] = { &tagval };
const int numval = 1;
// create all three types of tags
Tag dense, sparse, bit;
rval = moab.tag_get_handle( "test_dense", 1, MB_TYPE_INTEGER, dense, MB_TAG_DENSE | MB_TAG_EXCL );CHECK_ERR( rval );
rval = moab.tag_get_handle( "test_sparse", 1, MB_TYPE_INTEGER, sparse, MB_TAG_SPARSE | MB_TAG_EXCL );CHECK_ERR( rval );
rval = moab.tag_get_handle( "test_bit", 4, MB_TYPE_BIT, bit, MB_TAG_EXCL );CHECK_ERR( rval );
// for each tag type, check all four mechanisms for setting tag data
// (fixed and variable length given array or range).
EntityHandle handle = (EntityHandle)1;
Range handles;
handles.insert( handle );
rval = moab.tag_set_data( dense, &handle, 1, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( sparse, &handle, 1, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( bit, &handle, 1, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( dense, handles, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( sparse, handles, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( bit, handles, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_by_ptr( dense, &handle, 1, valarr, &numval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_by_ptr( sparse, &handle, 1, valarr, &numval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_by_ptr( dense, handles, valarr, &numval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_by_ptr( sparse, handles, valarr, &numval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
// now add create an entity and try an adjacent handle
EntityHandle set;
rval = moab.create_meshset( 0, set );CHECK_ERR( rval );
handle = (EntityHandle)( set + 1 );
handles.clear();
handles.insert( handle );
rval = moab.tag_set_data( dense, &handle, 1, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( sparse, &handle, 1, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( bit, &handle, 1, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( dense, handles, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( sparse, handles, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_data( bit, handles, &tagval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_by_ptr( dense, &handle, 1, valarr, &numval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_by_ptr( sparse, &handle, 1, valarr, &numval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_by_ptr( dense, handles, valarr, &numval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
rval = moab.tag_set_by_ptr( sparse, handles, valarr, &numval );
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
}
| ErrorCode set_bit_data | ( | Interface & | mb, |
| Tag | tag, | ||
| const Container & | handles, | ||
| const std::vector< unsigned char > & | data | ||
| ) |
Definition at line 1173 of file TagTest.cpp.
References ErrorCode, MB_SUCCESS, and moab::Interface::tag_set_data().
{
ErrorCode rval;
data.resize( handles.size() );
std::vector< unsigned char >::const_iterator j = data.begin();
for( typename Container::const_iterator i = handles.begin(); i != handles.end(); ++i, ++j )
{
rval = mb.tag_set_data( tag, &*i, 1, &*j );
if( MB_SUCCESS != rval ) return rval;
}
}
| void setup_mesh | ( | Interface & | mesh | ) |
Definition at line 1897 of file TagTest.cpp.
References moab::Range::begin(), CHECK_EQUAL, CHECK_ERR, moab::Interface::create_element(), moab::Interface::create_vertices(), moab::Interface::delete_entities(), ErrorCode, MBHEX, moab::Range::size(), and vertex_coords().
Referenced by test_clear_bit(), test_delete_bit_data(), test_delete_tag_data(), test_delete_type_tag(), test_get_by_tag(), test_get_by_tag_value(), test_get_by_tag_value_dense(), test_get_entity_tags(), test_get_set(), test_get_set_bit(), and test_get_set_variable_length().
{
Range vertex_handles;
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,
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,
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 };
const unsigned num_vtx = sizeof( vertex_coords ) / ( 3 * sizeof( double ) );
ErrorCode rval = mb.create_vertices( vertex_coords, num_vtx, vertex_handles );CHECK_ERR( rval );
CHECK_EQUAL( num_vtx, (unsigned)vertex_handles.size() );
CHECK_EQUAL( 27u, num_vtx );
EntityHandle elements[8];
EntityHandle conn[8][8] = { { 0, 1, 4, 3, 9, 10, 13, 12 }, { 1, 2, 5, 4, 10, 11, 14, 13 },
{ 3, 4, 7, 6, 12, 13, 16, 15 }, { 4, 5, 8, 7, 13, 14, 17, 16 },
{ 9, 10, 13, 12, 18, 19, 22, 21 }, { 10, 11, 14, 13, 19, 20, 23, 22 },
{ 12, 13, 16, 15, 21, 22, 25, 24 }, { 13, 14, 17, 16, 22, 23, 26, 25 } };
for( unsigned i = 0; i < 8; ++i )
{
rval = mb.create_element( MBHEX, conn[i], 8, elements[i] );CHECK_ERR( rval );
}
// delete some stuff so there are multiple sequences
rval = mb.delete_entities( elements + 2, 2 );CHECK_ERR( rval );
Range::iterator i = vertex_handles.begin();
i += 16;
rval = mb.delete_entities( &*i, 1 );CHECK_ERR( rval );
i += 2;
rval = mb.delete_entities( &*i, 1 );CHECK_ERR( rval );
}
| void test_bit_tag_big | ( | ) |
Definition at line 1827 of file TagTest.cpp.
References moab::Range::begin(), CHECK_EQUAL, CHECK_ERR, moab::Interface::create_vertices(), moab::Range::end(), ErrorCode, moab::Interface::get_entities_by_type_and_tag(), moab::Range::insert(), MB_TAG_BIT, MB_TYPE_BIT, MBVERTEX, moab::Range::rbegin(), moab::Range::rend(), moab::Range::size(), moab::Interface::tag_get_data(), moab::Interface::tag_set_data(), and test_create_tag().
Referenced by main().
{
Core moab;
Interface& mb = moab;
ErrorCode rval;
const size_t NUM_VTX = 30000;
// create a lot of vertices
std::vector< double > coords( 3 * NUM_VTX, 0.0 );
Range verts;
rval = mb.create_vertices( &coords[0], NUM_VTX, verts );CHECK_ERR( rval );
CHECK_EQUAL( NUM_VTX, (size_t)verts.size() );
// create a bit tag
Tag tag = test_create_tag( mb, "bb", 4, MB_TAG_BIT, MB_TYPE_BIT, 0 );
// for each vertex, store last four bits of handle as tag value
std::vector< unsigned char > values( NUM_VTX );
std::vector< unsigned char >::iterator it = values.begin();
for( Range::iterator j = verts.begin(); j != verts.end(); ++j, ++it )
*it = (unsigned char)( *j & 0xF );
rval = mb.tag_set_data( tag, verts, &values[0] );CHECK_ERR( rval );
// retrieve values
std::vector< unsigned char > values2( NUM_VTX, 0 );
rval = mb.tag_get_data( tag, verts, &values2[0] );
CHECK_EQUAL( values, values2 );
// retrieve individual values
it = values.begin();
for( Range::iterator j = verts.begin(); j != verts.end(); ++j, ++it )
{
char value;
rval = mb.tag_get_data( tag, &*j, 1, &value );CHECK_ERR( rval );
CHECK_EQUAL( *it, value );
}
// retrieve entities
unsigned char value = 0xC;
Range expected, results;
for( Range::reverse_iterator j = verts.rbegin(); j != verts.rend(); ++j )
if( (unsigned char)( *j & 0xF ) == value ) expected.insert( *j );
const void* vals[] = { &value };
rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, vals, 1, results );CHECK_ERR( rval );
CHECK_EQUAL( expected, results );
// test singe-bit tag
Tag tag1 = test_create_tag( mb, "bb1", 1, MB_TAG_BIT, MB_TYPE_BIT, 0 );
// set tag to 1 on all vertices
values.clear();
values.resize( NUM_VTX, '\001' );
rval = mb.tag_set_data( tag1, verts, &values[0] );CHECK_ERR( rval );
// retrieve values individually
for( Range::iterator j = verts.begin(); j != verts.end(); ++j )
{
char cvalue;
rval = mb.tag_get_data( tag1, &*j, 1, &cvalue );CHECK_ERR( rval );
CHECK_EQUAL( 1, (int)cvalue );
}
// clear values individually
for( Range::iterator j = verts.begin(); j != verts.end(); ++j )
{
char cvalue = '\0';
rval = mb.tag_set_data( tag1, &*j, 1, &cvalue );CHECK_ERR( rval );
}
// retrieve values using range
rval = mb.tag_get_data( tag1, verts, &values[0] );CHECK_ERR( rval );
size_t first_one = std::find( values.begin(), values.end(), '\001' ) - values.begin();
CHECK_EQUAL( values.size(), first_one );
}
| void test_clear_bit | ( | ) |
Definition at line 808 of file TagTest.cpp.
References moab::Range::begin(), CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::empty(), moab::Range::end(), entities, ErrorCode, moab::Interface::get_entities_by_handle(), mb, MB_TAG_BIT, MB_TYPE_BIT, setup_mesh(), moab::Interface::tag_clear_data(), moab::Interface::tag_get_data(), and test_create_tag().
Referenced by main().
{
// create mesh and tag
Core moab;
Interface& mb = moab;
setup_mesh( mb );
Tag tag = test_create_tag( mb, "clear_bit_val", 2, MB_TAG_BIT, MB_TYPE_BIT, 0 );
// get some handles to work with
Range entities;
ErrorCode rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
CHECK( !entities.empty() );
const unsigned char bits = 2;
rval = mb.tag_clear_data( tag, entities, &bits );CHECK_ERR( rval );
// set bits on every entity
for( Range::iterator i = entities.begin(); i != entities.end(); ++i )
{
unsigned char bits_out = 0;
rval = mb.tag_get_data( tag, &*i, 1, &bits_out );
CHECK_EQUAL( bits, bits_out );
}
}
| void test_clear_dense | ( | ) |
Definition at line 734 of file TagTest.cpp.
References MB_TAG_DENSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, ONE_VALUE, and test_get_set().
Referenced by main().
{
const int int_val = 0xcab;
test_get_set( "clear_dense_int", 1, MB_TAG_DENSE, MB_TYPE_INTEGER, &int_val, 1, 0, ONE_VALUE, false );
const double dbl_val[] = { 3.14159, -3.14159 };
const double default_val[] = { -2, 5 };
test_get_set( "clear_dense_double", 2, MB_TAG_DENSE, MB_TYPE_DOUBLE, &dbl_val, 1, default_val, ONE_VALUE, false );
}
| void test_clear_dense_varlen | ( | ) |
Definition at line 1746 of file TagTest.cpp.
References MB_TAG_DENSE, and test_clear_variable_length().
Referenced by main().
| void test_clear_sparse | ( | ) |
Definition at line 744 of file TagTest.cpp.
References MB_TAG_SPARSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, ONE_VALUE, and test_get_set().
Referenced by main().
{
const int int_val = 0xcab;
test_get_set( "clear_sparse_int", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, &int_val, 1, 0, ONE_VALUE, false );
const double dbl_val[] = { 3.14159, -3.14159 };
const double default_val[] = { -2, 5 };
test_get_set( "clear_sparse_double", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, &dbl_val, 1, default_val, ONE_VALUE, false );
}
| void test_clear_sparse_varlen | ( | ) |
Definition at line 1741 of file TagTest.cpp.
References MB_TAG_SPARSE, and test_clear_variable_length().
Referenced by main().
| void test_clear_variable_length | ( | TagType | storage | ) |
Definition at line 1726 of file TagTest.cpp.
References ints, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, and test_get_set_variable_length().
Referenced by test_clear_dense_varlen(), and test_clear_sparse_varlen().
{
const double doubles[3] = { 1e-1, 1e-2, 1e-3 };
const void* dvals[] = { doubles };
const int dlen = sizeof( doubles ) / sizeof( double );
test_get_set_variable_length( "vnodef_clear", storage, MB_TYPE_DOUBLE, dvals, &dlen, 1, 0, 0 );
const int ints[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15 };
const void* ivals[] = { ints };
const int ilen = sizeof( ints ) / sizeof( int );
const int defvals[] = { 42, 5, 8, 74 };
test_get_set_variable_length( "vdef_clear", storage, MB_TYPE_INTEGER, ivals, &ilen, 1, defvals, 4 );
}
| void test_create_tag | ( | ) |
Definition at line 297 of file TagTest.cpp.
References mb, MB_TAG_BIT, MB_TAG_DENSE, MB_TAG_SPARSE, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, and MB_TYPE_OPAQUE.
Referenced by main(), test_bit_tag_big(), test_clear_bit(), test_delete_bit_data(), test_delete_tag_data(), test_delete_type_tag(), test_get_by_tag(), test_get_by_tag_value(), test_get_by_tag_value_dense(), test_get_entity_tags(), test_get_ents_with_default_value(), test_get_set(), test_get_set_bit(), and test_mesh_value().
{
Core mb;
unsigned char defval[] = { 1, 2, 3, 4, 0, 0, 0, 0 };
// opaque tags
test_create_tag( mb, "opaque_tag_sparse", 8, MB_TAG_SPARSE, MB_TYPE_OPAQUE, defval );
test_create_tag( mb, "opaque_tag_dense", 4, MB_TAG_DENSE, MB_TYPE_OPAQUE, defval );
test_create_tag( mb, "opaque_tag_dense2", 1, MB_TAG_DENSE, MB_TYPE_OPAQUE, 0 );
// integer tags
test_create_tag( mb, "int_tag_sparse", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, defval );
test_create_tag( mb, "int_tag_dense", 8, MB_TAG_DENSE, MB_TYPE_INTEGER, 0 );
// double tags
double defval2[] = { 3.14159, 2.71828 };
test_create_tag( mb, "dbl_tag_sparse", 1, MB_TAG_SPARSE, MB_TYPE_DOUBLE, 0 );
test_create_tag( mb, "dbl_tag_dense", 2, MB_TAG_DENSE, MB_TYPE_DOUBLE, defval2 );
// handle tags
test_create_tag( mb, "h_tag_dense", 1, MB_TAG_DENSE, MB_TYPE_HANDLE, defval );
// bit tags
unsigned char def_bit_val = 0xBF;
test_create_tag( mb, "bit_tag_1", 2, MB_TAG_BIT, MB_TYPE_BIT, &def_bit_val );
}
| Tag test_create_tag | ( | Interface & | mb, |
| const char * | name, | ||
| int | num_vals, | ||
| TagType | storage, | ||
| DataType | type, | ||
| const void * | defval, | ||
| ErrorCode | expect = MB_SUCCESS |
||
| ) |
Definition at line 148 of file TagTest.cpp.
References CHECK, CHECK_EQUAL, CHECK_ERR, ErrorCode, MB_ALREADY_ALLOCATED, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TAG_EXCL, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, t, moab::Interface::tag_get_bytes(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_default_value(), moab::Interface::tag_get_handle(), moab::Interface::tag_get_length(), moab::Interface::tag_get_name(), moab::Interface::tag_get_type(), and TagType.
{
ErrorCode rval;
Tag tag;
rval = mb.tag_get_handle( name, num_vals, type, tag, storage | MB_TAG_EXCL, defval );
if( expect != MB_SUCCESS )
{
CHECK_EQUAL( expect, rval );
return 0;
}
CHECK_ERR( rval );
std::string n;
rval = mb.tag_get_name( tag, n );CHECK_ERR( rval );
CHECK( n == name );
Tag tag2;
rval = mb.tag_get_handle( name, num_vals, type, tag2 );CHECK_ERR( rval );
CHECK_EQUAL( tag, tag2 );
int s;
rval = mb.tag_get_length( tag, s );CHECK_ERR( rval );
CHECK_EQUAL( num_vals, s );
TagType t;
rval = mb.tag_get_type( tag, t );CHECK_ERR( rval );
CHECK_EQUAL( storage, t );
DataType d;
rval = mb.tag_get_data_type( tag, d );CHECK_ERR( rval );
CHECK_EQUAL( type, d );
int bytes;
rval = mb.tag_get_bytes( tag, bytes );CHECK_ERR( rval );
int exp_bytes = 0;
switch( type )
{
case MB_TYPE_INTEGER:
exp_bytes = num_vals * sizeof( int );
break;
case MB_TYPE_DOUBLE:
exp_bytes = num_vals * sizeof( double );
break;
case MB_TYPE_HANDLE:
exp_bytes = num_vals * sizeof( EntityHandle );
break;
case MB_TYPE_BIT:
exp_bytes = 1;
break;
case MB_TYPE_OPAQUE:
exp_bytes = num_vals;
break;
}
CHECK_EQUAL( exp_bytes, bytes );
std::vector< unsigned char > defv( bytes );
rval = mb.tag_get_default_value( tag, &defv[0] );
if( defval )
{
CHECK_ERR( rval );
CHECK( !memcmp( defval, &defv[0], bytes ) );
}
else
{
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
}
// make sure we can't create a second tag w/ the same name
rval = mb.tag_get_handle( name, num_vals, type, tag2, storage | MB_TAG_EXCL, defval );
CHECK_EQUAL( MB_ALREADY_ALLOCATED, rval );
// we should get back the handle of the existing tag
CHECK_EQUAL( tag, tag2 );
return tag;
}
| Tag test_create_var_len_tag | ( | Interface & | mb, |
| const char * | name, | ||
| TagType | storage, | ||
| DataType | type, | ||
| const void * | defval, | ||
| int | defval_size, | ||
| ErrorCode | expect = MB_SUCCESS |
||
| ) |
Definition at line 231 of file TagTest.cpp.
References CHECK, CHECK_EQUAL, CHECK_ERR, ErrorCode, MB_ALREADY_ALLOCATED, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TAG_EXCL, MB_TAG_VARLEN, MB_VARIABLE_DATA_LENGTH, size, t, moab::Interface::tag_get_bytes(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_default_value(), moab::Interface::tag_get_handle(), moab::Interface::tag_get_length(), moab::Interface::tag_get_name(), moab::Interface::tag_get_type(), and TagType.
Referenced by test_create_variable_length_tag(), test_get_set_variable_length(), and test_get_set_variable_length_mesh().
{
ErrorCode rval;
Tag tag;
rval = mb.tag_get_handle( name, defval_size, type, tag, storage | MB_TAG_VARLEN | MB_TAG_EXCL, defval );
if( expect != MB_SUCCESS )
{
CHECK_EQUAL( expect, rval );
return 0;
}
CHECK_ERR( rval );
std::string n;
rval = mb.tag_get_name( tag, n );CHECK_ERR( rval );
CHECK( n == name );
Tag tag2;
rval = mb.tag_get_handle( name, 0, type, tag2 );CHECK_ERR( rval );
CHECK_EQUAL( tag, tag2 );
int s;
rval = mb.tag_get_bytes( tag, s );
CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, rval );
rval = mb.tag_get_length( tag, s );
CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, rval );
// CHECK_ERR(rval);
// CHECK_EQUAL( MB_VARIABLE_LENGTH, s );
TagType t;
rval = mb.tag_get_type( tag, t );CHECK_ERR( rval );
CHECK_EQUAL( storage, t );
DataType d;
rval = mb.tag_get_data_type( tag, d );CHECK_ERR( rval );
CHECK_EQUAL( type, d );
int size;
const void* defv;
rval = mb.tag_get_default_value( tag, defv, size );
if( defval )
{
CHECK_ERR( rval );
CHECK_EQUAL( defval_size, size );
CHECK( !memcmp( defval, defv, size ) );
}
else
{
CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
}
// make sure we can't create a second tag w/ the same name
rval = mb.tag_get_handle( name, defval_size, type, tag2, storage | MB_TAG_VARLEN | MB_TAG_EXCL );
CHECK_EQUAL( MB_ALREADY_ALLOCATED, rval );
// we should get back the handle of the existing tag
CHECK_EQUAL( tag, tag2 );
return tag;
}
| void test_create_variable_length_tag | ( | ) |
Definition at line 324 of file TagTest.cpp.
References mb, MB_TAG_DENSE, MB_TAG_SPARSE, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, and test_create_var_len_tag().
Referenced by main().
{
Core mb;
unsigned char defval[] = { 1, 2, 3, 4, 0, 0, 0, 0 };
// opaque tags
const void* defptr = defval;
test_create_var_len_tag( mb, "opaque_tag_sparse", MB_TAG_SPARSE, MB_TYPE_OPAQUE, defptr, 8 );
test_create_var_len_tag( mb, "opaque_tag_dense", MB_TAG_DENSE, MB_TYPE_OPAQUE, defptr, 4 );
test_create_var_len_tag( mb, "opaque_tag_dense2", MB_TAG_DENSE, MB_TYPE_OPAQUE, 0, 0 );
// integer tags
test_create_var_len_tag( mb, "int_tag_sparse", MB_TAG_SPARSE, MB_TYPE_INTEGER, defptr, 1 );
test_create_var_len_tag( mb, "int_tag_dense", MB_TAG_DENSE, MB_TYPE_INTEGER, 0, 0 );
// double tags
double defval2[] = { 3.14159, 2.71828 };
defptr = defval2;
test_create_var_len_tag( mb, "dbl_tag_sparse", MB_TAG_SPARSE, MB_TYPE_DOUBLE, 0, 0 );
test_create_var_len_tag( mb, "dbl_tag_dense", MB_TAG_DENSE, MB_TYPE_DOUBLE, defptr, 2 );
// handle tags
test_create_var_len_tag( mb, "h_tag_dense", MB_TAG_DENSE, MB_TYPE_HANDLE, 0, 0 );
}
| void test_delete_bit_data | ( | ) |
Definition at line 1405 of file TagTest.cpp.
References CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::empty(), entities, ErrorCode, moab::Range::front(), moab::Interface::get_entities_by_handle(), MB_SUCCESS, MB_TAG_BIT, MB_TAG_NOT_FOUND, MB_TYPE_BIT, setup_mesh(), moab::Interface::tag_delete_data(), moab::Interface::tag_get_data(), moab::Interface::tag_set_data(), and test_create_tag().
Referenced by main().
{
Core moab;
Interface& mb = moab;
ErrorCode rval;
// get an entity to set data on
setup_mesh( mb );
Range entities;
rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
CHECK( !entities.empty() );
EntityHandle handle = entities.front();
// create two tags, one with a default value and one without
unsigned char defval = '\006'; // 110
Tag tag1, tag2;
tag1 = test_create_tag( mb, "tag1", 2, MB_TAG_BIT, MB_TYPE_BIT, 0 );
tag2 = test_create_tag( mb, "tag2", 3, MB_TAG_BIT, MB_TYPE_BIT, &defval );
// set value for each tag
unsigned char val = '\001';
rval = mb.tag_set_data( tag1, &handle, 1, &val );CHECK_ERR( rval );
rval = mb.tag_set_data( tag2, &handle, 1, &val );CHECK_ERR( rval );
// delete both tag values
rval = mb.tag_delete_data( tag1, &handle, 1 );CHECK_ERR( rval );
rval = mb.tag_delete_data( tag2, &handle, 1 );CHECK_ERR( rval );
// try to get value for tag w/out default.
// should get back either not found, or a zero value.
val = 0xFF;
rval = mb.tag_get_data( tag1, &handle, 1, &val );
if( MB_SUCCESS == rval )
CHECK_EQUAL( val, '\0' );
else
CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
// test that we get back default value for second tag
val = 0xFF;
rval = mb.tag_get_data( tag2, &handle, 1, &val );CHECK_ERR( rval );
CHECK_EQUAL( defval, val );
}
| void test_delete_dense_data | ( | ) |
Definition at line 1399 of file TagTest.cpp.
References MB_TAG_SPARSE, and test_delete_tag_data().
Referenced by main().
{
test_delete_tag_data( MB_TAG_SPARSE, false );
test_delete_tag_data( MB_TAG_SPARSE, true );
}
| void test_delete_dense_tag | ( | ) |
Definition at line 1286 of file TagTest.cpp.
References MB_TAG_DENSE, and test_delete_type_tag().
Referenced by main().
{
test_delete_type_tag( MB_TAG_DENSE );
}
| void test_delete_mesh_tag | ( | ) |
Definition at line 1291 of file TagTest.cpp.
References MB_TAG_MESH, and test_delete_type_tag().
Referenced by main().
{
test_delete_type_tag( MB_TAG_MESH );
}
| void test_delete_sparse_data | ( | ) |
Definition at line 1393 of file TagTest.cpp.
References MB_TAG_DENSE, and test_delete_tag_data().
Referenced by main().
{
test_delete_tag_data( MB_TAG_DENSE, false );
test_delete_tag_data( MB_TAG_DENSE, true );
}
| void test_delete_sparse_tag | ( | ) |
Definition at line 1281 of file TagTest.cpp.
References MB_TAG_SPARSE, and test_delete_type_tag().
Referenced by main().
{
test_delete_type_tag( MB_TAG_SPARSE );
}
| void test_delete_tag_data | ( | TagType | storage, |
| bool | with_default_value | ||
| ) |
Definition at line 1296 of file TagTest.cpp.
References moab::Range::begin(), CHECK, CHECK_ERR, moab::Range::end(), ErrorCode, moab::GeomUtil::first(), moab::Range::front(), moab::Interface::get_entities_by_handle(), moab::Range::insert(), MB_TAG_NOT_FOUND, MB_TAG_SPARSE, MB_TYPE_HANDLE, setup_mesh(), moab::Range::size(), moab::Interface::tag_delete_data(), moab::Interface::tag_get_data(), moab::Interface::tag_set_data(), tagname, and test_create_tag().
Referenced by test_delete_dense_data(), and test_delete_sparse_data().
{
Core moab;
Interface& mb = moab;
ErrorCode rval;
setup_mesh( mb );
// subdivide entity handles into three groups:
// 1) entities for which the tag data will be deleted using the array-based function
// 2) entities for which the tag data will be deleted using the range-based function
// 3) entities for which the tag data will not be deleted
Range all_entities, del1_range, keep_range;
std::vector< EntityHandle > del1_list, del2_list, keep_list;
rval = mb.get_entities_by_handle( 0, all_entities );CHECK_ERR( rval );
int c = 0;
for( Range::iterator i = all_entities.begin(); i != all_entities.end(); ++i, ++c )
{
switch( c % 3 )
{
case 0:
del1_range.insert( *i );
break;
case 1:
keep_range.insert( *i );
break;
case 2:
del2_list.push_back( *i );
break;
}
}
del1_list.resize( del1_range.size() );
std::copy( del1_range.begin(), del1_range.end(), del1_list.begin() );
keep_list.resize( keep_range.size() );
std::copy( keep_range.begin(), keep_range.end(), keep_list.begin() );
// create tag
EntityHandle first = all_entities.front();
EntityHandle* defval = with_default_value ? &first : 0;
const char* tagname = "dead_tag";
Tag tag = test_create_tag( mb, tagname, 1, storage, MB_TYPE_HANDLE, defval );
// set value for each entity to its handle
rval = mb.tag_set_data( tag, del1_range, &del1_list[0] );CHECK_ERR( rval );
rval = mb.tag_set_data( tag, keep_range, &keep_list[0] );CHECK_ERR( rval );
rval = mb.tag_set_data( tag, &del2_list[0], del2_list.size(), &del2_list[0] );CHECK_ERR( rval );
// delete tag data
rval = mb.tag_delete_data( tag, del1_range );CHECK_ERR( rval );
rval = mb.tag_delete_data( tag, &del2_list[0], del2_list.size() );CHECK_ERR( rval );
// test that keep list is unaffected
std::vector< EntityHandle > tag_data( keep_range.size(), 0 );
rval = mb.tag_get_data( tag, keep_range, &tag_data[0] );CHECK_ERR( rval );
CHECK( tag_data == keep_list );
// try to get data for deleted range
tag_data.clear();
tag_data.resize( del1_range.size(), (EntityHandle)-1 );
rval = mb.tag_get_data( tag, del1_range, &tag_data[0] );
// if we have a default value, should get that for deleted entities
if( with_default_value )
{
CHECK_ERR( rval );
std::vector< EntityHandle > expected( del1_range.size(), *defval );
CHECK( expected == tag_data );
}
else if( rval != MB_TAG_NOT_FOUND )
{
// dense and bit tags might return either MB_TAG_NOT_FOUND or zero bytes.
// sparse tags should always return MB_TAG_NOT_FOUND
CHECK( MB_TAG_SPARSE != storage );
std::vector< EntityHandle > expected( del1_range.size(), 0 );
CHECK( expected == tag_data );
}
// try to get data for deleted list
tag_data.clear();
tag_data.resize( del1_range.size(), (EntityHandle)-1 );
rval = mb.tag_get_data( tag, del1_range, &tag_data[0] );
// if we have a default value, should get that for deleted entities
if( with_default_value )
{
CHECK_ERR( rval );
std::vector< EntityHandle > expected( del1_range.size(), *defval );
CHECK( expected == tag_data );
}
else if( rval != MB_TAG_NOT_FOUND )
{
// dense and bit tags might return either MB_TAG_NOT_FOUND or zero bytes.
// sparse tags should always return MB_TAG_NOT_FOUND
CHECK( MB_TAG_SPARSE != storage );
std::vector< EntityHandle > expected( del1_range.size(), 0 );
CHECK( expected == tag_data );
}
}
| static void test_delete_type_tag | ( | TagType | storage | ) | [static] |
Definition at line 1101 of file TagTest.cpp.
References CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::empty(), ErrorCode, moab::Range::front(), moab::Interface::get_entities_by_type(), MB_TAG_MESH, MB_TAG_NOT_FOUND, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, MBVERTEX, mesh, setup_mesh(), size, moab::Interface::tag_delete(), moab::Interface::tag_get_bytes(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_default_value(), moab::Interface::tag_get_handle(), moab::Interface::tag_get_length(), moab::Interface::tag_get_name(), moab::Interface::tag_get_tags(), moab::Interface::tag_get_tags_on_entity(), moab::Interface::tag_set_data(), tagname, and test_create_tag().
Referenced by test_delete_dense_tag(), test_delete_mesh_tag(), and test_delete_sparse_tag().
{
Core moab;
Interface& mb = moab;
ErrorCode rval;
setup_mesh( mb );
// create tag
int default_val = 42;
const char* tagname = "dead_tag";
Tag tag = test_create_tag( mb, tagname, 1, storage, MB_TYPE_INTEGER, &default_val );
// get an entity handle to work with
Range verts;
rval = mb.get_entities_by_type( 0, MBVERTEX, verts );CHECK_ERR( rval );
CHECK( !verts.empty() );
EntityHandle handle = verts.front();
// set tag value on entity
int value = -5;
if( storage != MB_TAG_MESH )
{
rval = mb.tag_set_data( tag, &handle, 1, &value );CHECK_ERR( rval );
}
// set tag value on mesh
const EntityHandle mesh = 0;
value = 2;
rval = mb.tag_set_data( tag, &mesh, 1, &value );CHECK_ERR( rval );
// delete tag
rval = mb.tag_delete( tag );CHECK_ERR( rval );
// make sure all basic queries fail with MB_TAG_NOT_FOUND
std::string name;
rval = mb.tag_get_name( tag, name );
CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
Tag tag2;
rval = mb.tag_get_handle( tagname, 1, MB_TYPE_INTEGER, tag2 );
CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
int size;
rval = mb.tag_get_bytes( tag, size );
CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
rval = mb.tag_get_length( tag, size );
CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
// get get the type from the handle, so this still succeeds
// TagType storage2;
// rval = mb.tag_get_type( tag, storage2 );
// CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
DataType type;
rval = mb.tag_get_data_type( tag, type );
CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
rval = mb.tag_get_default_value( tag, &value );
CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
// check global list of tags
std::vector< Tag > tags;
rval = mb.tag_get_tags( tags );CHECK_ERR( rval );
CHECK( std::find( tags.begin(), tags.end(), tag ) == tags.end() );
// check tags on entity
tags.clear();
rval = mb.tag_get_tags_on_entity( handle, tags );CHECK_ERR( rval );
CHECK( std::find( tags.begin(), tags.end(), tag ) == tags.end() );
// check that a new tag w/ the same name can be created
tag = test_create_tag( mb, tagname, 1, storage, MB_TYPE_DOUBLE, 0 );
rval = mb.tag_delete( tag );CHECK_ERR( rval );
}
| void test_get_by_tag | ( | ) |
Definition at line 833 of file TagTest.cpp.
References moab::Interface::add_entities(), moab::Range::begin(), CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::clear(), moab::Interface::create_meshset(), moab::Range::empty(), entities, ErrorCode, moab::Interface::get_entities_by_type(), moab::Interface::get_entities_by_type_and_tag(), moab::Interface::get_number_entities_by_type_and_tag(), mb, MB_TAG_SPARSE, MB_TYPE_INTEGER, MBVERTEX, setup_mesh(), moab::Range::size(), moab::Interface::tag_set_data(), and test_create_tag().
Referenced by main().
{
// create mesh and tag
Core moab;
Interface& mb = moab;
setup_mesh( mb );
Tag tag = test_create_tag( mb, "sparse_count", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, 0 );
// get some handles to work with
Range entities;
ErrorCode rval = mb.get_entities_by_type( 0, MBVERTEX, entities );CHECK_ERR( rval );
CHECK( !entities.empty() );
// get five handles
CHECK( entities.size() > 6 );
EntityHandle arr[5] = { *( entities.begin() += entities.size() / 6 ),
*( entities.begin() += 2 * entities.size() / 6 ),
*( entities.begin() += 3 * entities.size() / 6 ),
*( entities.begin() += 4 * entities.size() / 6 ),
*( entities.begin() += 5 * entities.size() / 6 ) };
int values[5] = { 1, 2, 3, 4, 5 };
rval = mb.tag_set_data( tag, arr, 5, values );CHECK_ERR( rval );
const void* const valarr[1] = { 0 };
// put some in a mesh set
EntityHandle set;
const int num_in_set = 3;
rval = mb.create_meshset( 0, set );CHECK_ERR( rval );
rval = mb.add_entities( set, arr, num_in_set );CHECK_ERR( rval );
// try for whole mesh will null tag value array
int count = -1;
rval = mb.get_number_entities_by_type_and_tag( 0, MBVERTEX, &tag, 0, 1, count );CHECK_ERR( rval );
CHECK_EQUAL( 5, count );
// try for whole mesh will null tag value, but non-null array
count = -1;
rval = mb.get_number_entities_by_type_and_tag( 0, MBVERTEX, &tag, valarr, 1, count );CHECK_ERR( rval );
CHECK_EQUAL( 5, count );
// try for mesh set
rval = mb.get_number_entities_by_type_and_tag( set, MBVERTEX, &tag, 0, 1, count );CHECK_ERR( rval );
CHECK_EQUAL( num_in_set, count );
// try for whole mesh will null tag value array
Range found;
rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, 0, 1, found );CHECK_ERR( rval );
CHECK_EQUAL( 5u, (unsigned)found.size() );
Range::iterator i = found.begin();
CHECK_EQUAL( arr[0], *i );
++i;
CHECK_EQUAL( arr[1], *i );
++i;
CHECK_EQUAL( arr[2], *i );
++i;
CHECK_EQUAL( arr[3], *i );
++i;
CHECK_EQUAL( arr[4], *i );
// try for whole mesh will null tag value, but non-null array
found.clear();
rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, valarr, 1, found );CHECK_ERR( rval );
CHECK_EQUAL( 5u, (unsigned)found.size() );
i = found.begin();
CHECK_EQUAL( arr[0], *i );
++i;
CHECK_EQUAL( arr[1], *i );
++i;
CHECK_EQUAL( arr[2], *i );
++i;
CHECK_EQUAL( arr[3], *i );
++i;
CHECK_EQUAL( arr[4], *i );
// try for mesh set
found.clear();
rval = mb.get_entities_by_type_and_tag( set, MBVERTEX, &tag, 0, 1, found );CHECK_ERR( rval );
CHECK_EQUAL( 3u, (unsigned)found.size() );
i = found.begin();
CHECK_EQUAL( arr[0], *i );
++i;
CHECK_EQUAL( arr[1], *i );
++i;
CHECK_EQUAL( arr[2], *i );
}
| void test_get_by_tag_value | ( | ) |
Definition at line 919 of file TagTest.cpp.
References moab::Interface::add_entities(), moab::Range::begin(), CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::clear(), moab::Interface::create_meshset(), moab::Range::empty(), entities, ErrorCode, moab::Interface::get_entities_by_type(), moab::Interface::get_entities_by_type_and_tag(), moab::Interface::get_number_entities_by_type_and_tag(), MB_TAG_SPARSE, MB_TYPE_INTEGER, MBVERTEX, setup_mesh(), moab::Range::size(), moab::Interface::tag_set_data(), and test_create_tag().
Referenced by main().
{
// create mesh and tag
Core moab;
Interface& mb = moab;
setup_mesh( mb );
Tag tag = test_create_tag( mb, "sparse_count", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, 0 );
// get some handles to work with
Range entities;
ErrorCode rval = mb.get_entities_by_type( 0, MBVERTEX, entities );CHECK_ERR( rval );
CHECK( !entities.empty() );
// get five handles
CHECK( entities.size() > 6 );
EntityHandle arr[5] = { *( entities.begin() += entities.size() / 6 ),
*( entities.begin() += 2 * entities.size() / 6 ),
*( entities.begin() += 3 * entities.size() / 6 ),
*( entities.begin() += 4 * entities.size() / 6 ),
*( entities.begin() += 5 * entities.size() / 6 ) };
int values[5] = { 0xBEEF, 0xBEEF, 0xBEEF, 0xBEEF, 0xBEEF };
rval = mb.tag_set_data( tag, arr, 5, values );CHECK_ERR( rval );
const void* const valarr[1] = { values };
// put some in a mesh set
EntityHandle set;
const int num_in_set = 3;
rval = mb.create_meshset( 0, set );CHECK_ERR( rval );
rval = mb.add_entities( set, arr, num_in_set );CHECK_ERR( rval );
// try for whole mesh
int count = -1;
rval = mb.get_number_entities_by_type_and_tag( 0, MBVERTEX, &tag, valarr, 1, count );CHECK_ERR( rval );
CHECK_EQUAL( 5, count );
// try for mesh set
rval = mb.get_number_entities_by_type_and_tag( set, MBVERTEX, &tag, valarr, 1, count );CHECK_ERR( rval );
CHECK_EQUAL( num_in_set, count );
// try for whole mesh
Range found;
rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, valarr, 1, found );CHECK_ERR( rval );
CHECK_EQUAL( 5u, (unsigned)found.size() );
Range::iterator i = found.begin();
CHECK_EQUAL( arr[0], *i );
++i;
CHECK_EQUAL( arr[1], *i );
++i;
CHECK_EQUAL( arr[2], *i );
++i;
CHECK_EQUAL( arr[3], *i );
++i;
CHECK_EQUAL( arr[4], *i ); //++i;
// try for mesh set
found.clear();
rval = mb.get_entities_by_type_and_tag( set, MBVERTEX, &tag, valarr, 1, found );CHECK_ERR( rval );
CHECK_EQUAL( 3u, (unsigned)found.size() );
i = found.begin();
CHECK_EQUAL( arr[0], *i );
++i;
CHECK_EQUAL( arr[1], *i );
++i;
CHECK_EQUAL( arr[2], *i ); //++i;
}
| void test_get_by_tag_value_dense | ( | ) |
Definition at line 985 of file TagTest.cpp.
References moab::Range::back(), moab::Range::begin(), CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::clear(), moab::Range::empty(), moab::Range::erase(), ErrorCode, moab::Range::front(), moab::Interface::get_entities_by_type(), moab::Interface::get_entities_by_type_and_tag(), moab::Interface::INTERSECT, MB_TAG_DENSE, MB_TYPE_INTEGER, MBHEX, MBVERTEX, setup_mesh(), moab::Range::size(), moab::Interface::tag_clear_data(), moab::Interface::tag_set_data(), and test_create_tag().
Referenced by main().
{
// create mesh and tag
ErrorCode rval;
Core moab;
Interface& mb = moab;
setup_mesh( mb );
const int def_val = 0xABCD;
const int fill_val = 0xBEEF;
const int find_val = 0xFEED;
Tag tag = test_create_tag( mb, "dense_gbv", 1, MB_TAG_DENSE, MB_TYPE_INTEGER, &def_val );
// get some handles to work with
Range elements, vertices, results;
rval = mb.get_entities_by_type( 0, MBHEX, elements );CHECK_ERR( rval );
rval = mb.get_entities_by_type( 0, MBVERTEX, vertices );CHECK_ERR( rval );
CHECK( !elements.empty() );
// set tag on all vertices to fill_val
rval = mb.tag_clear_data( tag, vertices, &fill_val );CHECK_ERR( rval );
// select three handles
CHECK( elements.size() > 4 );
EntityHandle arr[3] = { *( elements.begin() += elements.size() / 4 ),
*( elements.begin() += 2 * elements.size() / 4 ),
*( elements.begin() += 3 * elements.size() / 4 ) };
int values[3] = { find_val, find_val, find_val };
rval = mb.tag_set_data( tag, arr, 3, values );CHECK_ERR( rval );
// get the entities tagged with 'find_val'
const void* const findarr[1] = { &find_val };
results.clear();
rval = mb.get_entities_by_type_and_tag( 0, MBHEX, &tag, findarr, 1, results );CHECK_ERR( rval );
CHECK_EQUAL( (size_t)3, results.size() );
CHECK_EQUAL( arr[0], results.front() );
CHECK_EQUAL( arr[1], *++results.begin() );
CHECK_EQUAL( arr[2], results.back() );
// should get no vertices
results.clear();
rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, findarr, 1, results );CHECK_ERR( rval );
CHECK( results.empty() );
// try intersecting with an existing range
results = elements;
results.erase( arr[1] );
results.insert( vertices.front() );
rval = mb.get_entities_by_type_and_tag( 0, MBHEX, &tag, findarr, 1, results, Interface::INTERSECT );CHECK_ERR( rval );
CHECK_EQUAL( (size_t)2, results.size() );
CHECK_EQUAL( arr[0], results.front() );
CHECK_EQUAL( arr[2], results.back() );
// try getting entities with default value
const void* const defarr[1] = { &def_val };
results.clear();
rval = mb.get_entities_by_type_and_tag( 0, MBHEX, &tag, defarr, 1, results );CHECK_ERR( rval );
CHECK_EQUAL( elements.size() - 3, results.size() );
Range expected( elements );
expected.erase( arr[0] );
expected.erase( arr[1] );
expected.erase( arr[2] );
CHECK( expected == results );
}
| void test_get_entity_tags | ( | ) |
Definition at line 1190 of file TagTest.cpp.
References moab::Range::begin(), CHECK, CHECK_ERR, contains_tag(), entities, ErrorCode, moab::Interface::get_entities_by_handle(), MB_TAG_BIT, MB_TAG_DENSE, MB_TAG_SPARSE, MB_TYPE_BIT, MB_TYPE_INTEGER, setup_mesh(), moab::Range::size(), moab::Interface::tag_get_tags_on_entity(), moab::Interface::tag_set_data(), and test_create_tag().
Referenced by main().
{
Core moab;
Interface& mb = moab;
ErrorCode rval;
// get 8 handles to work with
setup_mesh( mb );
Range entities;
rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
CHECK( entities.size() >= 8 );
Range::iterator i = entities.begin();
EntityHandle sparse_ent = *i;
++i;
EntityHandle dense_ent = *i;
++i;
EntityHandle bit_ent = *i;
++i;
EntityHandle sparse_dense_ent = *i;
++i;
EntityHandle sparse_bit_ent = *i;
++i;
EntityHandle dense_bit_ent = *i;
++i;
EntityHandle all_tag_ent = *i;
++i;
EntityHandle no_tag_ent = *i;
++i;
// create three tags to work with
Tag sparse, dense, bit;
sparse = test_create_tag( mb, "sparse", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, 0 );
dense = test_create_tag( mb, "dense_", 1, MB_TAG_DENSE, MB_TYPE_INTEGER, 0 );
bit = test_create_tag( mb, "bit___", 1, MB_TAG_BIT, MB_TYPE_BIT, 0 );
// set tags on handles
EntityHandle sparse_ents[4] = { sparse_ent, sparse_dense_ent, sparse_bit_ent, all_tag_ent };
EntityHandle dense_ents[4] = { dense_ent, sparse_dense_ent, dense_bit_ent, all_tag_ent };
EntityHandle bit_ents[4] = { bit_ent, sparse_bit_ent, dense_bit_ent, all_tag_ent };
int values[4] = { -1, -2, -3, -4 };
rval = mb.tag_set_data( sparse, sparse_ents, 4, &values );CHECK_ERR( rval );
rval = mb.tag_set_data( dense, dense_ents, 4, &values );CHECK_ERR( rval );
for( int j = 0; j < 4; ++j )
{
unsigned char bitval = 0xF;
rval = mb.tag_set_data( bit, bit_ents + j, 1, &bitval );CHECK_ERR( rval );
}
// get tags on each entity
std::vector< Tag > sparse_ent_tags, dense_ent_tags, bit_ent_tags, sparse_dense_ent_tags, sparse_bit_ent_tags,
dense_bit_ent_tags, all_tag_ent_tags, no_tag_ent_tags;
rval = mb.tag_get_tags_on_entity( sparse_ent, sparse_ent_tags );CHECK_ERR( rval );
rval = mb.tag_get_tags_on_entity( dense_ent, dense_ent_tags );CHECK_ERR( rval );
rval = mb.tag_get_tags_on_entity( bit_ent, bit_ent_tags );CHECK_ERR( rval );
rval = mb.tag_get_tags_on_entity( sparse_dense_ent, sparse_dense_ent_tags );CHECK_ERR( rval );
rval = mb.tag_get_tags_on_entity( sparse_bit_ent, sparse_bit_ent_tags );CHECK_ERR( rval );
rval = mb.tag_get_tags_on_entity( dense_bit_ent, dense_bit_ent_tags );CHECK_ERR( rval );
rval = mb.tag_get_tags_on_entity( all_tag_ent, all_tag_ent_tags );CHECK_ERR( rval );
rval = mb.tag_get_tags_on_entity( no_tag_ent, no_tag_ent_tags );CHECK_ERR( rval );
// check expected values
// NOTE: could potentially get back bit and dense tags for any entity
// depending on the storage layout. Only sparse tags guarantee
// no false positives. False negatives should never happen for any type.
// Also, there could be other dense tags already defined.
// verify sparse tag in all expected lists
CHECK( contains_tag( sparse, sparse_ent_tags ) );
CHECK( contains_tag( sparse, sparse_dense_ent_tags ) );
CHECK( contains_tag( sparse, sparse_bit_ent_tags ) );
CHECK( contains_tag( sparse, all_tag_ent_tags ) );
// verify sparse tag not in any other lists
CHECK( !contains_tag( sparse, dense_ent_tags ) );
CHECK( !contains_tag( sparse, bit_ent_tags ) );
CHECK( !contains_tag( sparse, dense_bit_ent_tags ) );
CHECK( !contains_tag( sparse, no_tag_ent_tags ) );
// verify dense tag in all expected lists
CHECK( contains_tag( dense, dense_ent_tags ) );
CHECK( contains_tag( dense, sparse_dense_ent_tags ) );
CHECK( contains_tag( dense, dense_bit_ent_tags ) );
CHECK( contains_tag( dense, all_tag_ent_tags ) );
// verify bit tag in all expected lists
CHECK( contains_tag( bit, bit_ent_tags ) );
CHECK( contains_tag( bit, sparse_bit_ent_tags ) );
CHECK( contains_tag( bit, dense_bit_ent_tags ) );
CHECK( contains_tag( bit, all_tag_ent_tags ) );
}
| void test_get_ents_with_default_value | ( | ) |
Definition at line 1751 of file TagTest.cpp.
References moab::Range::back(), moab::Range::begin(), CHECK_EQUAL, CHECK_ERR, moab::Range::clear(), moab::Interface::create_element(), moab::Interface::create_vertices(), moab::Range::end(), ErrorCode, moab::Range::front(), moab::Interface::get_entities_by_type_and_tag(), moab::Range::insert(), moab::Interface::INTERSECT, MB_TAG_DENSE, MB_TAG_SPARSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, MBEDGE, MBVERTEX, size, moab::Range::size(), moab::subtract(), moab::Interface::tag_set_data(), test_create_tag(), and moab::Interface::UNION.
Referenced by main().
{
Core moab;
Interface& mb = moab;
ErrorCode rval;
Range result;
// create a bunch of vertices
std::vector< double > coords( 90, 0.0 );
Range verts;
rval = mb.create_vertices( &coords[0], coords.size() / 3, verts );CHECK_ERR( rval );
CHECK_EQUAL( coords.size() / 3, (size_t)verts.size() );
// create one edge, which we should never get back from
// our queries with type == MBVERTEX
EntityHandle edge, ends[] = { verts.front(), verts.back() };
rval = mb.create_element( MBEDGE, ends, 2, edge );CHECK_ERR( rval );
// split vertices into four groups
Range sets[4];
size_t s = 0;
for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
{
sets[s].insert( *i );
s = ( s + 1 ) % 4;
}
// create a sparse tag and set some verts to non-default value
int default_sparse = 5;
Tag tag_sparse = test_create_tag( mb, "int", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, &default_sparse );
std::vector< int > sparse_vals( sets[0].size(), -1 );
rval = mb.tag_set_data( tag_sparse, sets[0], &sparse_vals[0] );CHECK_ERR( rval );
// get all entities with default value for sparse tag
result.clear();
const void* ptrs[] = { &default_sparse };
rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag_sparse, ptrs, 1, result );CHECK_ERR( rval );
CHECK_EQUAL( subtract( verts, sets[0] ), result );
// create a dense tag and set some verts to non-default value
double default_dense = -1.0;
Tag tag_dense = test_create_tag( mb, "double", 1, MB_TAG_DENSE, MB_TYPE_DOUBLE, &default_dense );
std::vector< double > dense_vals( sets[1].size(), 3.14159 );
rval = mb.tag_set_data( tag_dense, sets[1], &dense_vals[0] );CHECK_ERR( rval );
// get all entities with default value for dense tag
result.clear();
ptrs[0] = &default_dense;
rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag_dense, ptrs, 1, result );CHECK_ERR( rval );
CHECK_EQUAL( subtract( verts, sets[1] ), result );
// create a variable-length tag and set some verts to non-default value
// SKIP THIS: NO API FOR QUERYING ENTITIES WITH VARIABLE-LENGTH VALUE
// int default_vlen[] = { 1, 2, 3 };
// Tag tag_vlen = test_create_var_len_tag( mb, "vlen", MB_TAG_SPARSE, MB_TYPE_INTEGER,
// default_vlen, sizeof(default_vlen) ); int other_vlen[] = { 4, 5, 6, 7 }; std::vector<const
// void*> vlen_ptrs( sets[2].size(), other_vlen ); std::vector<int> vlen_sizes( sets[2].size)(),
// sizeof(other_vlen) ); rval = mb.tag_set_data( tag_vlen, sets[2], &vlen_ptrs[0],
// &vlen_sizes[0]
// ); CHECK_ERR(rval);
// check that INTERSECT option works as expected
result.clear();
result.insert( sets[1].front() );
ptrs[0] = &default_sparse;
rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag_sparse, ptrs, 1, result, Interface::INTERSECT );CHECK_ERR( rval );
CHECK_EQUAL( (size_t)1, result.size() );
CHECK_EQUAL( sets[1].front(), result.front() );
// check that UNITE option works as expected
result.clear();
result.insert( edge );
ptrs[0] = &default_sparse;
rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag_sparse, ptrs, 1, result, Interface::UNION );CHECK_ERR( rval );
CHECK_EQUAL( edge, result.back() );
}
| void test_get_pointers_dense | ( | ) |
Definition at line 690 of file TagTest.cpp.
References MB_TAG_DENSE, MB_TYPE_OPAQUE, NORMAL, and test_get_set().
Referenced by main().
{
const unsigned char data[] = "a few aribtrary bytes entered as a string";
const int num_val = sizeof( data ) / sizeof( data[0] );
test_get_set( "dense_byte_ptr", 2, MB_TAG_DENSE, MB_TYPE_OPAQUE, data, num_val / 2, 0, NORMAL, true );
const unsigned char defaultval[] = "XY";
test_get_set( "dense_byte_ptr_def", 2, MB_TAG_DENSE, MB_TYPE_OPAQUE, data, num_val / 2, defaultval, NORMAL, true );
}
| void test_get_pointers_sparse | ( | ) |
Definition at line 679 of file TagTest.cpp.
References MB_TAG_SPARSE, MB_TYPE_DOUBLE, NORMAL, and test_get_set().
Referenced by main().
{
const double data[] = { 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 16 };
const int num_val = sizeof( data ) / sizeof( data[0] );
test_get_set( "sparse_dbl_ptr", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, data, num_val / 2, 0, NORMAL, true );
const double defaultval[] = { -1, -2 };
test_get_set( "sparse_dbl_ptr_def", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, data, num_val / 2, defaultval, NORMAL, true );
}
| void test_get_set | ( | const char * | name, |
| int | vals_per_ent, | ||
| TagType | storage, | ||
| DataType | type, | ||
| const void * | some_values, | ||
| int | num_values, | ||
| const void * | default_value, | ||
| SetMode | set_by_pointer = NORMAL, |
||
| bool | get_by_pointer = false |
||
| ) |
Definition at line 361 of file TagTest.cpp.
References moab::Range::begin(), CHECK, CHECK_EQUAL, CHECK_ERR, concat_to_list(), moab::Range::const_pair_begin(), moab::Range::const_pair_end(), moab::Range::empty(), entities, moab::Range::erase(), ErrorCode, moab::Interface::get_entities_by_handle(), h1, moab::Range::insert(), mb, MB_TAG_DENSE, MB_TAG_NOT_FOUND, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, NORMAL, ONE_VALUE, POINTER, setup_mesh(), moab::Range::size(), moab::subtract(), moab::Interface::tag_clear_data(), moab::Interface::tag_get_by_ptr(), moab::Interface::tag_get_data(), moab::Interface::tag_set_by_ptr(), moab::Interface::tag_set_data(), and test_create_tag().
{
std::vector< unsigned char > data;
// create mesh and tag
Core moab;
Interface& mb = moab;
setup_mesh( mb );
Tag tag = test_create_tag( mb, name, vals_per_ent, storage, type, default_value );
// get some handles to work with
Range entities;
ErrorCode rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
CHECK( !entities.empty() );
int bytes = 0;
switch( type )
{
case MB_TYPE_INTEGER:
bytes = vals_per_ent * sizeof( int );
break;
case MB_TYPE_DOUBLE:
bytes = vals_per_ent * sizeof( double );
break;
case MB_TYPE_HANDLE:
bytes = vals_per_ent * sizeof( EntityHandle );
break;
case MB_TYPE_BIT:
bytes = 1;
break;
case MB_TYPE_OPAQUE:
bytes = vals_per_ent;
break;
}
// split handles into four groups
// a) a single handle
// b) some non-consecutive handles in an array
// c) some handles in an Range
// d) remaining handles (remaining in 'entities');
EntityHandle one_handle;
Range::iterator it = entities.begin() += entities.size() / 2;
one_handle = *it;
entities.erase( it );
Range handle_range;
std::vector< EntityHandle > handle_list;
for( Range::const_pair_iterator i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
{
if( i->first == i->second || i->second - i->first == 1 )
{
EntityHandle h1 = i->first, h2 = i->second;
++i;
handle_range.insert( h1, h2 );
}
else
{
EntityHandle mid = (EntityHandle)( i->first + ( i->second - i->first + 1 ) / 2 );
handle_list.push_back( mid );
handle_range.insert( mid + 1, i->second );
}
}
entities = subtract( entities, handle_range );
for( unsigned i = 0; i < handle_list.size(); ++i )
entities.erase( handle_list[i] );
// try getting/setting single handle value
std::vector< const void* > list( 1 );
if( set_mode == NORMAL )
{
rval = mb.tag_set_data( tag, &one_handle, 1, some_values );
}
else if( set_mode == POINTER )
{
list[0] = some_values;
rval = mb.tag_set_by_ptr( tag, &one_handle, 1, &list[0] );
}
else
{ // set_mode == ONE_VALUE
rval = mb.tag_clear_data( tag, &one_handle, 1, some_values );
}
CHECK_ERR( rval );
data.resize( bytes );
if( get_by_pointer )
{
// test that correct size is returned
int rsize;
rval = mb.tag_get_by_ptr( tag, &one_handle, 1, &list[0], &rsize );CHECK_ERR( rval );
CHECK_EQUAL( vals_per_ent, rsize );
// try again with NULL size pointer
list[0] = 0;
rval = mb.tag_get_by_ptr( tag, &one_handle, 1, &list[0] );CHECK_ERR( rval );
CHECK( !memcmp( some_values, list[0], bytes ) );
}
else
{
rval = mb.tag_get_data( tag, &one_handle, 1, &data[0] );CHECK_ERR( rval );
CHECK( !memcmp( some_values, &data[0], bytes ) );
}
// try getting/setting for arrays of handles
const int step = std::min( (int)handle_list.size(), num_values );
data.resize( step * bytes );
for( int i = 0; i < (int)handle_list.size(); i += step )
{
const int n = std::min( (int)handle_list.size() - i, step );
list.resize( n );
if( set_mode == NORMAL )
{
rval = mb.tag_set_data( tag, &handle_list[i], n, some_values );
}
else if( set_mode == POINTER )
{
concat_to_list( some_values, list, bytes );
rval = mb.tag_set_by_ptr( tag, &handle_list[i], n, &list[0] );
}
else
{
rval = mb.tag_clear_data( tag, &handle_list[i], n, some_values );
}
CHECK_ERR( rval );
if( get_by_pointer )
{
// check that valid sizes are returned if requested
std::vector< int > rsizes( n, 0 );
rval = mb.tag_get_by_ptr( tag, &handle_list[i], n, &list[0], &rsizes[0] );CHECK_ERR( rval );
for( int j = 0; j < n; ++j )
CHECK_EQUAL( vals_per_ent, rsizes[j] );
// query a second time to verify that it works w/ NULL size array
list.clear();
list.resize( n, 0 );
rval = mb.tag_get_by_ptr( tag, &handle_list[i], n, &list[0] );
}
else
{
rval = mb.tag_get_data( tag, &handle_list[i], n, &data[0] );
concat_to_list( &data[0], list, bytes );
}
CHECK_ERR( rval );
const unsigned char* ptr = reinterpret_cast< const unsigned char* >( some_values );
for( int j = 0; j < n; ++j, ptr += bytes )
CHECK( !memcmp( ptr, list[j], bytes ) );
}
// try getting/setting for Range of handles
// set data for range
if( set_mode == NORMAL )
{
std::vector< unsigned char > input_data( handle_range.size() * bytes );
for( int i = 0; i < (int)input_data.size(); i += num_values * bytes )
memcpy( &input_data[i], some_values, std::min( (int)input_data.size() - i, num_values * bytes ) );
rval = mb.tag_set_data( tag, handle_range, &input_data[0] );
}
else if( set_mode == POINTER )
{
list.resize( num_values );
concat_to_list( some_values, list, bytes );
while( list.size() < handle_range.size() )
{
size_t s = list.size();
list.resize( 2 * s );
std::copy( list.begin(), list.begin() + s, list.begin() + s );
}
rval = mb.tag_set_by_ptr( tag, handle_range, &list[0] );
}
else
{
rval = mb.tag_clear_data( tag, handle_range, some_values );
}
CHECK_ERR( rval );
// get data for range
list.clear();
list.resize( handle_range.size(), 0 );
if( get_by_pointer )
{
// check that valid sizes are returned if requested
std::vector< int > rsizes( handle_range.size(), 0 );
rval = mb.tag_get_by_ptr( tag, handle_range, &list[0], &rsizes[0] );CHECK_ERR( rval );
for( size_t j = 0; j < handle_range.size(); ++j )
CHECK_EQUAL( vals_per_ent, rsizes[j] );
// query w/ NULL size array to make sure that works also
list.clear();
list.resize( handle_range.size(), 0 );
rval = mb.tag_get_by_ptr( tag, handle_range, &list[0] );
}
else
{
data.resize( handle_range.size() * bytes );
concat_to_list( &data[0], list, bytes );
rval = mb.tag_get_data( tag, handle_range, &data[0] );
}
CHECK_ERR( rval );
// compare values
const bool dstep = ( set_mode != ONE_VALUE );
for( size_t i = 0; i < list.size(); ++i )
{
CHECK( list[i * dstep] != NULL );
const void* ptr = reinterpret_cast< const char* >( some_values ) + ( i % num_values ) * bytes;
CHECK( !memcmp( list[i * dstep], ptr, bytes ) );
}
// try getting unset values
list.resize( entities.size() );
if( get_by_pointer )
{
rval = mb.tag_get_by_ptr( tag, entities, &list[0] );
}
else
{
data.clear(), data.resize( entities.size() * bytes, '\001' );
concat_to_list( &data[0], list, bytes );
rval = mb.tag_get_data( tag, entities, &data[0] );
}
// if there was a default value, we should have gotten it for all unset entities
if( default_value )
{
CHECK_ERR( rval );
for( unsigned i = 0; i < entities.size(); ++i )
CHECK( !memcmp( default_value, list[i], bytes ) );
}
// otherwise we should get MB_TAG_NOT_FOUND, *unless* the tag
// is dense, in which case we /might/ get all zero bytes instead.
else if( MB_TAG_NOT_FOUND != rval )
{
CHECK_EQUAL( MB_TAG_DENSE, storage );
std::vector< unsigned char > zeros( bytes, 0 );
for( unsigned i = 0; i < entities.size(); ++i )
CHECK( !memcmp( &zeros[0], list[i], bytes ) );
}
// Check that handles for other entities didn't change.
// Ignore get_by_pointer/set_by_pointer flags from here on.
// We've established (hopefully) that both methods work in
// the above code. Now we just want to verify correct values,
// regardless of the API used to get them.
// one handle
data.resize( bytes );
rval = mb.tag_get_data( tag, &one_handle, 1, &data[0] );CHECK_ERR( rval );
CHECK( !memcmp( some_values, &data[0], bytes ) );
// array values
data.resize( step * bytes );
for( int i = 0; i < (int)handle_list.size(); i += step )
{
const int n = std::min( (int)handle_list.size() - i, step );
rval = mb.tag_get_data( tag, &handle_list[i], n, &data[0] );CHECK_ERR( rval );
CHECK( !memcmp( some_values, &data[0], step * bytes ) );
rval = mb.tag_set_data( tag, &handle_list[i], n, some_values );CHECK_ERR( rval );
}
// range values
list.clear();
list.resize( handle_range.size(), 0 );
rval = mb.tag_get_by_ptr( tag, handle_range, &list[0] );CHECK_ERR( rval );
for( size_t i = 0; i < handle_range.size(); ++i )
{
const void* ptr = reinterpret_cast< const char* >( some_values ) + ( i % num_values ) * bytes;
CHECK( !memcmp( ptr, list[i], bytes ) );
}
}
| void test_get_set_bit | ( | ) |
Definition at line 754 of file TagTest.cpp.
References moab::Range::begin(), CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::empty(), moab::Range::end(), entities, ErrorCode, moab::Interface::get_entities_by_handle(), h1, mb, MB_TAG_BIT, MB_TYPE_BIT, setup_mesh(), moab::Range::size(), moab::Interface::tag_get_data(), moab::Interface::tag_set_data(), and test_create_tag().
Referenced by main().
{
// create mesh and tag
Core moab;
Interface& mb = moab;
setup_mesh( mb );
Tag tag = test_create_tag( mb, "bit_val", 2, MB_TAG_BIT, MB_TYPE_BIT, 0 );
// get some handles to work with
Range entities;
ErrorCode rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
CHECK( !entities.empty() );
// set bits on every entity
unsigned counter = 0;
for( Range::iterator i = entities.begin(); i != entities.end(); ++i )
{
srand( counter++ );
unsigned char bits = (unsigned char)( rand() & 3 );
rval = mb.tag_set_data( tag, &*i, 1, &bits );CHECK_ERR( rval );
unsigned char bits_out = 0;
rval = mb.tag_get_data( tag, &*i, 1, &bits_out );CHECK_ERR( rval );
CHECK_EQUAL( bits, bits_out );
}
// test default value
unsigned char defval = '\003';
unsigned char zero = '\0';
Tag tag2 = test_create_tag( mb, "bit_val2", 3, MB_TAG_BIT, MB_TYPE_BIT, &defval );
CHECK( entities.size() >= 3 );
Range::iterator j = entities.begin();
EntityHandle h1 = *j;
++j;
EntityHandle h2 = *j;
++j;
EntityHandle h3 = *j;
++j;
rval = mb.tag_set_data( tag2, &h1, 1, &zero );CHECK_ERR( rval );
rval = mb.tag_set_data( tag2, &h3, 1, &zero );CHECK_ERR( rval );
unsigned char byte;
rval = mb.tag_get_data( tag2, &h2, 1, &byte );CHECK_ERR( rval );
CHECK_EQUAL( defval, byte );
rval = mb.tag_get_data( tag2, &h1, 1, &byte );CHECK_ERR( rval );
CHECK_EQUAL( zero, byte );
rval = mb.tag_get_data( tag2, &h3, 1, &byte );CHECK_ERR( rval );
CHECK_EQUAL( zero, byte );
// test default value for uninitialized data (tag not set for any entity)
defval = '\002';
Tag tag3 = test_create_tag( mb, "bit_val3", 2, MB_TAG_BIT, MB_TYPE_BIT, &defval );
rval = mb.tag_get_data( tag3, &h2, 1, &byte );CHECK_ERR( rval );
CHECK_EQUAL( defval, byte );
}
| void test_get_set_dense_double | ( | ) |
Definition at line 664 of file TagTest.cpp.
References MB_TAG_DENSE, MB_TYPE_DOUBLE, and test_get_set().
Referenced by main().
{
const double pi = 3.1415926535897931;
const double e = 2.7182818284590451;
const double data[] = { 1, 1., pi, e, 2, 1. / 2, 2 * pi, e / 2, 3, 1. / 3,
3 * pi, e / 3, 4, 1. / 4, 4 * pi, e / 4, 5, 1. / 5, 5 * pi, e / 5,
6, 1. / 6, 6 * pi, e / 6, 0, 100, 1000, 10000 };
const int num_val = sizeof( data ) / sizeof( data[0] );
test_get_set( "dense_dbl", 1, MB_TAG_DENSE, MB_TYPE_DOUBLE, data, num_val, 0 );
const double defaultval[] = { 0.11, 0.22 };
test_get_set( "dense_dbl_def", 2, MB_TAG_DENSE, MB_TYPE_DOUBLE, data, num_val / 2, defaultval );
}
| void test_get_set_dense_int | ( | ) |
Definition at line 652 of file TagTest.cpp.
References MB_TAG_DENSE, MB_TYPE_INTEGER, and test_get_set().
Referenced by main().
{
const int data[] = { 231, 416, 294, 504, 318, 558, 494, 006, 464, 648, 737, 045, 179, 852, 944, 336,
773, 248, 434, 615, 677, 667, 521, 748, 820, 533, 955, 300, 108, 726, 747, 597 };
const int num_val = sizeof( data ) / sizeof( data[0] );
test_get_set( "dense_int", 1, MB_TAG_DENSE, MB_TYPE_INTEGER, data, num_val, 0 );
const int defaultval[] = { 5, 8, 1974 };
test_get_set( "dense_int_def", 3, MB_TAG_DENSE, MB_TYPE_INTEGER, data, num_val / 3, defaultval );
}
| void test_get_set_sparse_int | ( | ) |
Definition at line 640 of file TagTest.cpp.
References MB_TAG_SPARSE, MB_TYPE_INTEGER, and test_get_set().
Referenced by main().
{
const int data[] = { 21, 00, 46, 30, 26, 63, 05, 49, 31, 39, 86, 77, 24, 37, 25, 98,
26, 20, 01, 54, 16, 28, 55, 49, 96, 18, 28, 18, 53, 00, 80, 48 };
const int num_val = sizeof( data ) / sizeof( data[0] );
test_get_set( "sparse_int", 2, MB_TAG_SPARSE, MB_TYPE_INTEGER, data, num_val / 2, 0 );
const int defaultval = 19740508;
test_get_set( "sparse_int_def", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, data, num_val, &defaultval );
}
| void test_get_set_variable_length | ( | const char * | name, |
| TagType | storage, | ||
| DataType | type, | ||
| const void ** | values, | ||
| const int * | lengths, | ||
| int | num_values, | ||
| const void * | default_value, | ||
| int | default_value_length | ||
| ) |
Definition at line 1448 of file TagTest.cpp.
References moab::Range::begin(), CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::const_pair_begin(), moab::Range::const_pair_end(), moab::Range::empty(), entities, moab::Range::erase(), ErrorCode, moab::Interface::get_entities_by_handle(), h1, moab::Range::insert(), MB_TAG_NOT_FOUND, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, setup_mesh(), moab::Range::size(), moab::subtract(), moab::Interface::tag_clear_data(), moab::Interface::tag_get_by_ptr(), moab::Interface::tag_set_by_ptr(), and test_create_var_len_tag().
Referenced by test_clear_variable_length(), test_get_set_variable_length_dense(), and test_get_set_variable_length_sparse().
{
std::vector< const void* > data;
std::vector< int > data_lens;
// create mesh and tag
Core moab;
Interface& mb = moab;
setup_mesh( mb );
Tag tag = test_create_var_len_tag( mb, name, storage, type, default_value, default_value_length );
// get some handles to work with
Range entities;
ErrorCode rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
CHECK( !entities.empty() );
// split handles into four groups
// a) a single handle
// b) some non-consecutive handles in an array
// c) some handles in an Range
// d) remaining handles (remaining in 'entities');
EntityHandle one_handle;
Range::iterator it = entities.begin() += entities.size() / 2;
one_handle = *it;
entities.erase( it );
Range handle_range;
std::vector< EntityHandle > handle_list;
for( Range::const_pair_iterator i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
{
if( i->first == i->second || i->second - i->first == 1 )
{
EntityHandle h1 = i->first, h2 = i->second;
++i;
handle_range.insert( h1, h2 );
}
else
{
EntityHandle mid = (EntityHandle)( i->first + ( i->second - i->first + 1 ) / 2 );
handle_list.push_back( mid );
handle_range.insert( mid + 1, i->second );
}
}
entities = subtract( entities, handle_range );
for( unsigned i = 0; i < handle_list.size(); ++i )
entities.erase( handle_list[i] );
// try getting/setting single handle value
if( num_values == 1 )
rval = mb.tag_clear_data( tag, &one_handle, 1, values[0], lengths[0] );
else
rval = mb.tag_set_by_ptr( tag, &one_handle, 1, values, lengths );CHECK_ERR( rval );
const void* data_ptr;
int data_len;
rval = mb.tag_get_by_ptr( tag, &one_handle, 1, &data_ptr, &data_len );CHECK_ERR( rval );
CHECK_EQUAL( lengths[0], data_len );
CHECK( !memcmp( values[0], data_ptr, data_len ) );
int typesize = 0;
switch( type )
{
case MB_TYPE_INTEGER:
typesize = sizeof( int );
break;
case MB_TYPE_DOUBLE:
typesize = sizeof( double );
break;
case MB_TYPE_HANDLE:
typesize = sizeof( EntityHandle );
break;
case MB_TYPE_BIT:
typesize = 1;
break;
case MB_TYPE_OPAQUE:
typesize = 1;
break;
}
// try getting/setting for arrays of handles
int count, step;
if( num_values == 1 )
{
count = handle_list.size();
step = 0;
rval = mb.tag_clear_data( tag, &handle_list[0], count, values[0], lengths[0] );
}
else
{
count = std::min( (int)handle_list.size(), num_values );
step = 1;
rval = mb.tag_set_by_ptr( tag, &handle_list[0], count, values, lengths );
}
CHECK_ERR( rval );
data.clear();
data.resize( count, 0 );
data_lens.clear();
data_lens.resize( count, 0 );
rval = mb.tag_get_by_ptr( tag, &handle_list[0], count, &data[0], &data_lens[0] );CHECK_ERR( rval );
for( int i = 0; i < count; ++i )
{
CHECK_EQUAL( lengths[i * step], data_lens[i] );
CHECK( NULL != data[i] );
CHECK( !memcmp( values[i], data[i * step], typesize * lengths[i * step] ) );
}
// try getting/setting for Range of handles
if( num_values > 1 )
{
data.resize( num_values );
data_lens.resize( num_values );
std::copy( values, values + num_values, data.begin() );
std::copy( lengths, lengths + num_values, data_lens.begin() );
while( data.size() < handle_range.size() )
{
size_t s = data.size();
data.resize( 2 * s );
std::copy( data.begin(), data.begin() + s, data.begin() + s );
data_lens.resize( 2 * s );
std::copy( data_lens.begin(), data_lens.begin() + s, data_lens.begin() + s );
}
rval = mb.tag_set_by_ptr( tag, handle_range, &data[0], &data_lens[0] );
}
else
{
rval = mb.tag_clear_data( tag, handle_range, values[0], lengths[0] );
}
CHECK_ERR( rval );
data.clear();
data.resize( handle_range.size(), 0 );
data_lens.clear();
data_lens.resize( handle_range.size(), 0 );
rval = mb.tag_get_by_ptr( tag, handle_range, &data[0], &data_lens[0] );CHECK_ERR( rval );
for( size_t i = 0; i < data.size(); ++i )
{
const void* expect = values[( i * step ) % num_values];
int expect_len = lengths[( i * step ) % num_values];
CHECK_EQUAL( expect_len, data_lens[i] );
CHECK( NULL != data[i] );
CHECK( !memcmp( expect, data[i], expect_len * typesize ) );
}
// try getting unset values
data.resize( entities.size() );
data_lens.resize( entities.size() );
rval = mb.tag_get_by_ptr( tag, entities, &data[0], &data_lens[0] );
// if there was a default value, we should have gotten it for all unset entities
if( default_value )
{
CHECK_ERR( rval );
for( unsigned i = 0; i < entities.size(); ++i )
{
CHECK_EQUAL( default_value_length, data_lens[i] );
CHECK( NULL != data[i] );
CHECK( !memcmp( default_value, data[i], typesize * default_value_length ) );
}
}
// otherwise we should get MB_TAG_NOT_FOUND
else
{
CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
}
// Check that handles for other entities didn't change.
// one handle
rval = mb.tag_get_by_ptr( tag, &one_handle, 1, &data_ptr, &data_len );CHECK_ERR( rval );
CHECK_EQUAL( lengths[0], data_len );
CHECK( !memcmp( values[0], data_ptr, typesize * data_len ) );
// array values
count = std::min( (int)handle_list.size(), num_values );
data.clear();
data.resize( count, 0 );
data_lens.clear();
data_lens.resize( count, 0 );
rval = mb.tag_get_by_ptr( tag, &handle_list[0], count, &data[0], &data_lens[0] );CHECK_ERR( rval );
for( int i = 0; i < count; ++i )
{
CHECK_EQUAL( lengths[i], data_lens[i] );
CHECK( NULL != data[i] );
CHECK( !memcmp( values[i], data[i], typesize * lengths[i] ) );
}
// range values
data.clear();
data.resize( handle_range.size(), 0 );
data_lens.clear();
data_lens.resize( handle_range.size(), 0 );
rval = mb.tag_get_by_ptr( tag, handle_range, &data[0], &data_lens[0] );CHECK_ERR( rval );
for( size_t i = 0; i < data.size(); ++i )
{
const void* expect = values[i % num_values];
int expect_len = lengths[i % num_values];
CHECK_EQUAL( expect_len, data_lens[i] );
CHECK( NULL != data[i] );
CHECK( !memcmp( expect, data[i], typesize * expect_len ) );
}
}
| void test_get_set_variable_length_dense | ( | ) |
Definition at line 1676 of file TagTest.cpp.
References ints, MB_TAG_DENSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, and test_get_set_variable_length().
Referenced by main().
{
const double doubles[14] = { 1, 2, 3, 4, -4, -3, -2, -1, 42, 0, 1974, -0.5, 1. / 3, -1e-10 };
const void* dvals[5] = { doubles, doubles + 3, doubles + 4, doubles + 8, doubles + 10 };
const int dlens[5] = { 3, 1, 4, 2, 4 };
test_get_set_variable_length( "vnodef", MB_TAG_DENSE, MB_TYPE_DOUBLE, dvals, dlens, 5, 0, 0 );
const int ints[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15 };
const void* ivals[9] = { ints, ints + 1, ints + 3, ints + 12, ints + 17,
ints + 21, ints + 28, ints + 29, ints + 31 };
const int ilens[9] = { 1, 2, 9, 5, 4, 7, 1, 2, 1 };
const int defvals[] = { 42, 5, 8, 74 };
test_get_set_variable_length( "vdef", MB_TAG_DENSE, MB_TYPE_INTEGER, ivals, ilens, 9, defvals, 4 );
}
| void test_get_set_variable_length_mesh | ( | ) |
Definition at line 1692 of file TagTest.cpp.
References CHECK_EQUAL, CHECK_ERR, ErrorCode, MB_TAG_MESH, MB_TYPE_INTEGER, mesh, moab::Interface::tag_get_by_ptr(), moab::Interface::tag_set_by_ptr(), and test_create_var_len_tag().
Referenced by main().
{
Core moab;
Interface& mb = moab;
ErrorCode rval;
Tag tag = test_create_var_len_tag( mb, "vmesh", MB_TAG_MESH, MB_TYPE_INTEGER, 0, 0 );
int values1[] = { 6 };
int values5[] = { 1, 2, 3, 4, 5 };
int one = 1;
const void* data[1];
data[0] = values1;
const EntityHandle mesh = 0;
rval = mb.tag_set_by_ptr( tag, &mesh, 1, data, &one );CHECK_ERR( rval );
int len;
rval = mb.tag_get_by_ptr( tag, &mesh, 1, data, &len );CHECK_ERR( rval );
CHECK_EQUAL( 1, len );
CHECK_EQUAL( values1[0], *reinterpret_cast< const int* >( data[0] ) );
int five = 5;
data[0] = values5;
rval = mb.tag_set_by_ptr( tag, &mesh, 1, data, &five );CHECK_ERR( rval );
rval = mb.tag_get_by_ptr( tag, &mesh, 1, data, &len );CHECK_ERR( rval );
CHECK_EQUAL( 5, len );
CHECK_EQUAL( values5[0], reinterpret_cast< const int* >( data[0] )[0] );
CHECK_EQUAL( values5[1], reinterpret_cast< const int* >( data[0] )[1] );
CHECK_EQUAL( values5[2], reinterpret_cast< const int* >( data[0] )[2] );
CHECK_EQUAL( values5[3], reinterpret_cast< const int* >( data[0] )[3] );
CHECK_EQUAL( values5[4], reinterpret_cast< const int* >( data[0] )[4] );
}
| void test_get_set_variable_length_sparse | ( | ) |
Definition at line 1660 of file TagTest.cpp.
References ints, MB_TAG_SPARSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, and test_get_set_variable_length().
Referenced by main().
{
const double doubles[14] = { 1, 2, 3, 4, -4, -3, -2, -1, 42, 0, 1974, -0.5, 1. / 3, -1e-10 };
const void* dvals[5] = { doubles, doubles + 3, doubles + 4, doubles + 8, doubles + 10 };
const int dlens[5] = { 3, 1, 4, 2, 4 };
test_get_set_variable_length( "vnodef", MB_TAG_SPARSE, MB_TYPE_DOUBLE, dvals, dlens, 5, 0, 0 );
const int ints[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15 };
const void* ivals[9] = { ints, ints + 1, ints + 3, ints + 12, ints + 17,
ints + 21, ints + 28, ints + 29, ints + 31 };
const int ilens[9] = { 1, 2, 9, 5, 4, 7, 1, 2, 1 };
const int defvals[] = { 42, 5, 8, 74 };
test_get_set_variable_length( "vdef", MB_TAG_SPARSE, MB_TYPE_INTEGER, ivals, ilens, 9, defvals, 4 );
}
| void test_mesh_value | ( | ) |
Definition at line 1084 of file TagTest.cpp.
References MB_TAG_BIT, MB_TAG_DENSE, MB_TAG_MESH, MB_TAG_SPARSE, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, and MB_TYPE_INTEGER.
Referenced by main().
{
Core moab;
double dval = -0.5;
test_mesh_value( moab, "mvd", 1, MB_TAG_DENSE, MB_TYPE_DOUBLE, &dval );
int sval = 42;
test_mesh_value( moab, "mvs", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, &sval );
EntityHandle mval = 0;
test_mesh_value( moab, "mvm", 1, MB_TAG_MESH, MB_TYPE_HANDLE, &mval );
unsigned char bits = '\002';
test_mesh_value( moab, "mvb", 2, MB_TAG_BIT, MB_TYPE_BIT, &bits );
}
| void test_mesh_value | ( | Interface & | mb, |
| const char * | tag_name, | ||
| unsigned | tag_size, | ||
| TagType | tag_storage, | ||
| DataType | tag_type, | ||
| const void * | value | ||
| ) |
Definition at line 1049 of file TagTest.cpp.
References CHECK, CHECK_ERR, ErrorCode, MB_TAG_BIT, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, mesh, moab::Interface::tag_get_data(), moab::Interface::tag_set_data(), and test_create_tag().
{
// create tag
Tag tag = test_create_tag( mb, tag_name, tag_size, tag_storage, tag_type, 0 );
unsigned memcmp_size = tag_size;
if( tag_storage == MB_TAG_BIT || tag_type == MB_TYPE_BIT )
memcmp_size = 1;
else if( tag_type == MB_TYPE_DOUBLE )
memcmp_size = sizeof( double );
else if( tag_type == MB_TYPE_INTEGER )
memcmp_size = sizeof( int );
if( tag_type == MB_TYPE_HANDLE ) memcmp_size = sizeof( EntityHandle );
const EntityHandle mesh = 0;
ErrorCode rval = mb.tag_set_data( tag, &mesh, 1, value );CHECK_ERR( rval );
std::vector< unsigned char > bytes( memcmp_size, 0 );
rval = mb.tag_get_data( tag, &mesh, 1, &bytes[0] );CHECK_ERR( rval );
CHECK( !memcmp( value, &bytes[0], memcmp_size ) );
// test again, this time for default value
std::string name2( tag_name );
name2 += "_DEF";
Tag tag2 = test_create_tag( mb, name2.c_str(), tag_size, tag_storage, tag_type, value );
bytes.clear();
bytes.resize( memcmp_size, 0 );
rval = mb.tag_get_data( tag2, &mesh, 1, &bytes[0] );CHECK_ERR( rval );
CHECK( !memcmp( value, &bytes[0], memcmp_size ) );
}
| void test_set_pointers_dense | ( | ) |
Definition at line 713 of file TagTest.cpp.
References MB_TAG_DENSE, MB_TYPE_DOUBLE, MB_TYPE_OPAQUE, POINTER, and test_get_set().
Referenced by main().
{
const unsigned char data[] = "a few aribtrary bytes entered as a string";
const int num_val = sizeof( data ) / sizeof( data[0] );
test_get_set( "dense_byte_ptr", 2, MB_TAG_DENSE, MB_TYPE_OPAQUE, data, num_val / 2, 0, POINTER, false );
const unsigned char defaultval[] = "XY";
test_get_set( "dense_byte_ptr_def", 2, MB_TAG_DENSE, MB_TYPE_OPAQUE, data, num_val / 2, defaultval, POINTER,
false );
const double dbldata[3] = { 1.0, 2.0, 3.0 };
const int dbl_num_val = sizeof( dbldata ) / sizeof( double );
test_get_set( "dense_double_ptr", 3, MB_TAG_DENSE, MB_TYPE_DOUBLE, dbldata, dbl_num_val, 0, POINTER, false );
const double dbldefaultval[3] = { 0.0, 0.0, 0.0 };
test_get_set( "dense_byte_ptr_def", 3, MB_TAG_DENSE, MB_TYPE_DOUBLE, dbldata, dbl_num_val, dbldefaultval, POINTER,
false );
}
| void test_set_pointers_sparse | ( | ) |
Definition at line 701 of file TagTest.cpp.
References MB_TAG_SPARSE, MB_TYPE_DOUBLE, POINTER, and test_get_set().
Referenced by main().
{
const double data[] = { 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 16 };
const int num_val = sizeof( data ) / sizeof( data[0] );
test_get_set( "sparse_dbl_ptr", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, data, num_val / 2, 0, POINTER, false );
const double defaultval[] = { -1, -2 };
test_get_set( "sparse_dbl_ptr_def", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, data, num_val / 2, defaultval, POINTER,
false );
}
| void test_tag_iterate_common | ( | TagType | storage, |
| bool | with_default | ||
| ) |
Definition at line 2037 of file TagTest.cpp.
References moab::Range::begin(), CHECK, CHECK_ARRAYS_EQUAL, CHECK_EQUAL, CHECK_ERR, moab::Interface::create_vertices(), moab::Interface::delete_entities(), moab::Range::end(), moab::Range::erase(), ErrorCode, moab::Range::insert(), MB_ENTITY_NOT_FOUND, MB_TAG_CREAT, MB_TAG_NOT_FOUND, MB_TAG_SPARSE, MB_TYPE_INTEGER, moab::Range::size(), moab::Interface::tag_get_handle(), moab::Interface::tag_iterate(), and moab::Interface::tag_set_data().
Referenced by test_tag_iterate_dense(), test_tag_iterate_dense_default(), test_tag_iterate_sparse(), and test_tag_iterate_sparse_default().
{
// create 1000 vertices
const int NUM_VTX = 1000;
Core moab;
Interface& mb = moab;
std::vector< double > coords( 3 * NUM_VTX );
Range verts, dead;
ErrorCode rval = mb.create_vertices( &coords[0], NUM_VTX, verts );CHECK_ERR( rval );
// delete about 1% of vertices
const int step = 100;
int remaining = NUM_VTX;
Range::iterator i = verts.begin();
for( int j = 0; j < remaining; j += step )
{
rval = mb.delete_entities( &*i, 1 );CHECK_ERR( rval );
dead.insert( *i );
i = verts.erase( i );
i += step - 1;
}
// Remove some additional values from the range
// so that our handle blocks don't always align with
// sequences
verts.erase( verts.begin() + ( step - 5 ), verts.begin() + ( step + 5 ) );
// Create an integer tag
Tag tag;
const int defval = 0;
rval = mb.tag_get_handle( "TEST_TAG", 1, MB_TYPE_INTEGER, tag, storage | MB_TAG_CREAT, with_default ? &defval : 0 );CHECK_ERR( rval );
// Set tag values
std::vector< int > values( verts.size(), defval );
if( !with_default )
{
for( size_t j = 0; j < values.size(); ++j )
values[j] = j;
rval = mb.tag_set_data( tag, verts, &values[0] );CHECK_ERR( rval );
}
// Check that we get back expected values
i = verts.begin();
void* ptr;
int count, total = 0;
while( i != verts.end() )
{
ptr = 0;
rval = mb.tag_iterate( tag, i, verts.end(), count, ptr );CHECK_ERR( rval );
assert( total + count <= (int)verts.size() );
CHECK_ARRAYS_EQUAL( &values[total], count, reinterpret_cast< int* >( ptr ), count );
if( i == verts.begin() && with_default && storage == MB_TAG_SPARSE ) ( (int*)ptr )[0] = 1.0;
i += count;
total += count;
}
// Check that we can set values
i = verts.begin();
while( i != verts.end() )
{
ptr = 0;
rval = mb.tag_iterate( tag, i, verts.end(), count, ptr );CHECK_ERR( rval );
Range::iterator end = i + count;
int* arr = reinterpret_cast< int* >( ptr );
while( end != i )
{
*arr = static_cast< int >( ( *i ) % NUM_VTX );
++i;
++arr;
}
}
// Check that we got back the values that we set
i = verts.begin();
while( i != verts.end() )
{
ptr = 0;
rval = mb.tag_iterate( tag, i, verts.end(), count, ptr );CHECK_ERR( rval );
Range::iterator end = i + count;
int* arr = reinterpret_cast< int* >( ptr );
while( end != i )
{
CHECK_EQUAL( *arr, static_cast< int >( ( *i ) % NUM_VTX ) );
++i;
++arr;
}
}
// Check that we cannot get tag values for invalid handles
rval = mb.tag_iterate( tag, dead.begin(), dead.end(), count, ptr );
CHECK( MB_ENTITY_NOT_FOUND == rval || MB_TAG_NOT_FOUND == rval );
}
| void test_tag_iterate_dense | ( | ) |
Definition at line 2142 of file TagTest.cpp.
References MB_TAG_DENSE, and test_tag_iterate_common().
Referenced by main().
{
test_tag_iterate_common( MB_TAG_DENSE, false );
}
| void test_tag_iterate_dense_default | ( | ) |
Definition at line 2146 of file TagTest.cpp.
References MB_TAG_DENSE, and test_tag_iterate_common().
Referenced by main().
{
test_tag_iterate_common( MB_TAG_DENSE, true );
}
| void test_tag_iterate_invalid | ( | ) |
Definition at line 2151 of file TagTest.cpp.
References moab::Range::begin(), CHECK_EQUAL, CHECK_ERR, moab::Interface::create_vertices(), moab::Range::end(), ErrorCode, MB_TAG_DENSE, MB_TAG_EXCL, MB_TAG_SPARSE, MB_TAG_VARLEN, MB_TYPE_BIT, MB_TYPE_INTEGER, MB_TYPE_OUT_OF_RANGE, MB_VARIABLE_DATA_LENGTH, moab::Interface::tag_get_handle(), and moab::Interface::tag_iterate().
Referenced by main().
{
// create 1000 vertices
const int NUM_VTX = 1000;
Core moab;
Interface& mb = moab;
std::vector< double > coords( 3 * NUM_VTX );
Range verts;
ErrorCode rval = mb.create_vertices( &coords[0], NUM_VTX, verts );CHECK_ERR( rval );
Tag tag;
const int zero = 0;
void* ptr;
int count;
// Check that we cannot iterate over bit tags
// (this will never be possible because the storage for bit tags
// is compressed and therefore cannot be directly accessed.)
rval = mb.tag_get_handle( "bits", 1, MB_TYPE_BIT, tag, MB_TAG_EXCL, &zero );CHECK_ERR( rval );
rval = mb.tag_iterate( tag, verts.begin(), verts.end(), count, ptr );
CHECK_EQUAL( MB_TYPE_OUT_OF_RANGE, rval );
// Check that we cannot iterate over variable-length tags
// (this will never be possible because this API function cannot
// pass back the length of the tag values)
rval = mb.tag_get_handle( "vden", 1, MB_TYPE_INTEGER, tag, MB_TAG_VARLEN | MB_TAG_DENSE | MB_TAG_EXCL, &zero );CHECK_ERR( rval );
rval = mb.tag_iterate( tag, verts.begin(), verts.end(), count, ptr );
CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, rval );
rval = mb.tag_get_handle( "vspr", 1, MB_TYPE_INTEGER, tag, MB_TAG_VARLEN | MB_TAG_SPARSE | MB_TAG_EXCL, &zero );CHECK_ERR( rval );
rval = mb.tag_iterate( tag, verts.begin(), verts.end(), count, ptr );
CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, rval );
}
| void test_tag_iterate_sparse | ( | ) |
Definition at line 2134 of file TagTest.cpp.
References MB_TAG_SPARSE, and test_tag_iterate_common().
Referenced by main().
{
test_tag_iterate_common( MB_TAG_SPARSE, false );
}
| void test_tag_iterate_sparse_default | ( | ) |
Definition at line 2138 of file TagTest.cpp.
References MB_TAG_SPARSE, and test_tag_iterate_common().
Referenced by main().
{
test_tag_iterate_common( MB_TAG_SPARSE, true );
}
1.7.6.1