MOAB: Mesh Oriented datABase  (version 5.5.0)
Enumerations | Functions
TagTest.cpp File Reference
#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.

Enumerations

enum  SetMode { NORMAL , POINTER , ONE_VALUE }
 

Functions

void test_create_tag ()
 
void test_get_set_sparse_int ()
 
void test_get_set_dense_int ()
 
void test_get_set_dense_double ()
 
void test_get_set_bit ()
 
void test_get_by_tag ()
 
void test_get_by_tag_value ()
 
void test_get_by_tag_value_dense ()
 
void test_mesh_value ()
 
void test_get_pointers_sparse ()
 
void test_get_pointers_dense ()
 
void test_set_pointers_sparse ()
 
void test_set_pointers_dense ()
 
void test_get_entity_tags ()
 
void test_delete_sparse_tag ()
 
void test_delete_dense_tag ()
 
void test_delete_mesh_tag ()
 
void test_delete_sparse_data ()
 
void test_delete_dense_data ()
 
void test_delete_bit_data ()
 
void test_create_variable_length_tag ()
 
void test_get_set_variable_length_sparse ()
 
void test_get_set_variable_length_dense ()
 
void test_get_set_variable_length_mesh ()
 
void test_get_ents_with_default_value ()
 
void test_bit_tag_big ()
 
void test_clear_dense ()
 
void test_clear_sparse ()
 
void test_clear_bit ()
 
void test_clear_dense_varlen ()
 
void test_clear_sparse_varlen ()
 
void test_tag_iterate_sparse ()
 
void test_tag_iterate_dense ()
 
void test_tag_iterate_sparse_default ()
 
void test_tag_iterate_dense_default ()
 
void test_tag_iterate_invalid ()
 
void regression_one_entity_by_var_tag ()
 
void regression_tag_on_nonexistent_entity ()
 
int main ()
 
void setup_mesh (Interface &mesh)
 
Tag test_create_tag (Interface &mb, const char *name, int num_vals, TagType storage, DataType type, const void *defval, ErrorCode expect=MB_SUCCESS)
 
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)
 
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)
 
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)
 
void test_mesh_value (Interface &mb, const char *tag_name, unsigned tag_size, TagType tag_storage, DataType tag_type, const void *value)
 
static void concat_to_list (const void *concat, std::vector< const void * > &list, size_t bytes)
 
static void test_delete_type_tag (TagType storage)
 
template<typename Container >
ErrorCode set_bit_data (Interface &mb, Tag tag, const Container &handles, const std::vector< unsigned char > &data)
 
static bool contains_tag (Tag tag, const std::vector< Tag > &list)
 
void test_delete_tag_data (TagType storage, bool with_default_value)
 
void test_clear_variable_length (TagType storage)
 
void test_tag_iterate_common (TagType storage, bool with_default)
 

Enumeration Type Documentation

◆ SetMode

enum SetMode
Enumerator
NORMAL 
POINTER 
ONE_VALUE 

Definition at line 115 of file TagTest.cpp.

116 {
117  NORMAL,
118  POINTER,
119  ONE_VALUE
120 };

Function Documentation

◆ concat_to_list()

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.

353 {
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 )
357  *iter = ptr;
358 }

Referenced by test_get_set().

◆ contains_tag()

static bool contains_tag ( Tag  tag,
const std::vector< Tag > &  list 
)
static

Definition at line 1185 of file TagTest.cpp.

1186 {
1187  return std::find( list.begin(), list.end(), tag ) != list.end();
1188 }

Referenced by test_get_entity_tags().

◆ main()

int main ( )

Definition at line 49 of file TagTest.cpp.

50 {
51  int failures = 0;
52 
53  failures += RUN_TEST( test_create_tag );
54  failures += RUN_TEST( test_get_set_sparse_int );
55  failures += RUN_TEST( test_get_set_dense_int );
56  failures += RUN_TEST( test_get_set_dense_double );
57  failures += RUN_TEST( test_get_set_bit );
58  failures += RUN_TEST( test_get_by_tag );
59  failures += RUN_TEST( test_get_by_tag_value );
60  failures += RUN_TEST( test_get_by_tag_value_dense );
61  failures += RUN_TEST( test_mesh_value );
62  failures += RUN_TEST( test_get_pointers_sparse );
63  failures += RUN_TEST( test_get_pointers_dense );
64  failures += RUN_TEST( test_set_pointers_sparse );
65  failures += RUN_TEST( test_set_pointers_dense );
66  failures += RUN_TEST( test_get_entity_tags );
67  failures += RUN_TEST( test_delete_sparse_tag );
68  failures += RUN_TEST( test_delete_dense_tag );
69  failures += RUN_TEST( test_delete_mesh_tag );
70  failures += RUN_TEST( test_delete_sparse_data );
71  failures += RUN_TEST( test_delete_dense_data );
72  failures += RUN_TEST( test_delete_bit_data );
73  failures += RUN_TEST( test_create_variable_length_tag );
74  failures += RUN_TEST( test_get_set_variable_length_sparse );
75  failures += RUN_TEST( test_get_set_variable_length_dense );
76  failures += RUN_TEST( test_get_set_variable_length_mesh );
77  failures += RUN_TEST( test_get_ents_with_default_value );
78  failures += RUN_TEST( test_bit_tag_big );
79  failures += RUN_TEST( regression_one_entity_by_var_tag );
80  failures += RUN_TEST( regression_tag_on_nonexistent_entity );
81  failures += RUN_TEST( test_clear_dense );
82  failures += RUN_TEST( test_clear_sparse );
83  failures += RUN_TEST( test_clear_bit );
84  failures += RUN_TEST( test_clear_dense_varlen );
85  failures += RUN_TEST( test_clear_sparse_varlen );
86  failures += RUN_TEST( test_tag_iterate_sparse );
87  failures += RUN_TEST( test_tag_iterate_dense );
88  failures += RUN_TEST( test_tag_iterate_sparse_default );
89  failures += RUN_TEST( test_tag_iterate_dense_default );
90  failures += RUN_TEST( test_tag_iterate_invalid );
91 
92  if( failures ) std::cerr << "<<<< " << failures << " TESTS FAILED >>>>" << std::endl;
93 
94  return failures;
95 }

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().

◆ regression_one_entity_by_var_tag()

void regression_one_entity_by_var_tag ( )

Definition at line 1934 of file TagTest.cpp.

1935 {
1936  Core moab;
1937  ErrorCode rval;
1938 
1939  EntityHandle vertex;
1940  const double coords[] = { 0, 0, 0 };
1941  rval = moab.create_vertex( coords, vertex );CHECK_ERR( rval );
1942 
1943  Tag tag;
1944  rval = moab.tag_get_handle( "testtag", 0, MB_TYPE_INTEGER, tag, MB_TAG_DENSE | MB_TAG_VARLEN | MB_TAG_EXCL );CHECK_ERR( rval );
1945 
1946  int taglen = 1;
1947  const void* ptrarr[1] = { &taglen };
1948  rval = moab.tag_set_by_ptr( tag, &vertex, 1, ptrarr, &taglen );CHECK_ERR( rval );
1949 
1950  Range ents;
1951  rval = moab.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, 0, 1, ents );CHECK_ERR( rval );
1952 
1953  CHECK_EQUAL( (size_t)1, ents.size() );
1954  CHECK_EQUAL( vertex, ents.front() );
1955 }

References CHECK_EQUAL, CHECK_ERR, ErrorCode, moab::Range::front(), MB_TAG_DENSE, MB_TAG_EXCL, MB_TAG_VARLEN, MB_TYPE_INTEGER, MBVERTEX, and moab::Range::size().

Referenced by main().

◆ regression_tag_on_nonexistent_entity()

void regression_tag_on_nonexistent_entity ( )

Definition at line 1960 of file TagTest.cpp.

1961 {
1962  Core moab;
1963  ErrorCode rval;
1964  const int tagval = 0xdeadbeef;
1965  const void* valarr[1] = { &tagval };
1966  const int numval = 1;
1967 
1968  // create all three types of tags
1969  Tag dense, sparse, bit;
1970  rval = moab.tag_get_handle( "test_dense", 1, MB_TYPE_INTEGER, dense, MB_TAG_DENSE | MB_TAG_EXCL );CHECK_ERR( rval );
1971  rval = moab.tag_get_handle( "test_sparse", 1, MB_TYPE_INTEGER, sparse, MB_TAG_SPARSE | MB_TAG_EXCL );CHECK_ERR( rval );
1972  rval = moab.tag_get_handle( "test_bit", 4, MB_TYPE_BIT, bit, MB_TAG_EXCL );CHECK_ERR( rval );
1973 
1974  // for each tag type, check all four mechanisms for setting tag data
1975  // (fixed and variable length given array or range).
1976  EntityHandle handle = (EntityHandle)1;
1977  Range handles;
1978  handles.insert( handle );
1979 
1980  rval = moab.tag_set_data( dense, &handle, 1, &tagval );
1981  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
1982  rval = moab.tag_set_data( sparse, &handle, 1, &tagval );
1983  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
1984  rval = moab.tag_set_data( bit, &handle, 1, &tagval );
1985  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
1986 
1987  rval = moab.tag_set_data( dense, handles, &tagval );
1988  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
1989  rval = moab.tag_set_data( sparse, handles, &tagval );
1990  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
1991  rval = moab.tag_set_data( bit, handles, &tagval );
1992  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
1993 
1994  rval = moab.tag_set_by_ptr( dense, &handle, 1, valarr, &numval );
1995  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
1996  rval = moab.tag_set_by_ptr( sparse, &handle, 1, valarr, &numval );
1997  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
1998 
1999  rval = moab.tag_set_by_ptr( dense, handles, valarr, &numval );
2000  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2001  rval = moab.tag_set_by_ptr( sparse, handles, valarr, &numval );
2002  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2003 
2004  // now add create an entity and try an adjacent handle
2005  EntityHandle set;
2006  rval = moab.create_meshset( 0, set );CHECK_ERR( rval );
2007 
2008  handle = (EntityHandle)( set + 1 );
2009  handles.clear();
2010  handles.insert( handle );
2011 
2012  rval = moab.tag_set_data( dense, &handle, 1, &tagval );
2013  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2014  rval = moab.tag_set_data( sparse, &handle, 1, &tagval );
2015  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2016  rval = moab.tag_set_data( bit, &handle, 1, &tagval );
2017  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2018 
2019  rval = moab.tag_set_data( dense, handles, &tagval );
2020  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2021  rval = moab.tag_set_data( sparse, handles, &tagval );
2022  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2023  rval = moab.tag_set_data( bit, handles, &tagval );
2024  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2025 
2026  rval = moab.tag_set_by_ptr( dense, &handle, 1, valarr, &numval );
2027  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2028  rval = moab.tag_set_by_ptr( sparse, &handle, 1, valarr, &numval );
2029  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2030 
2031  rval = moab.tag_set_by_ptr( dense, handles, valarr, &numval );
2032  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2033  rval = moab.tag_set_by_ptr( sparse, handles, valarr, &numval );
2034  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
2035 }

References CHECK_EQUAL, CHECK_ERR, moab::Range::clear(), ErrorCode, moab::Range::insert(), MB_ENTITY_NOT_FOUND, MB_TAG_DENSE, MB_TAG_EXCL, MB_TAG_SPARSE, MB_TYPE_BIT, and MB_TYPE_INTEGER.

Referenced by main().

◆ set_bit_data()

template<typename Container >
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.

1174 {
1175  ErrorCode rval;
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 )
1179  {
1180  rval = mb.tag_set_data( tag, &*i, 1, &*j );
1181  if( MB_SUCCESS != rval ) return rval;
1182  }
1183 }

References ErrorCode, mb, MB_SUCCESS, and moab::Core::tag_set_data().

◆ setup_mesh()

void setup_mesh ( Interface &  mesh)

Definition at line 1897 of file TagTest.cpp.

1898 {
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,
1901 
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,
1903 
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 ) );
1906  ErrorCode rval = mb.create_vertices( vertex_coords, num_vtx, vertex_handles );CHECK_ERR( rval );
1907  CHECK_EQUAL( num_vtx, (unsigned)vertex_handles.size() );
1908 
1909  CHECK_EQUAL( 27u, num_vtx );
1910  EntityHandle elements[8];
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 )
1916  {
1917  rval = mb.create_element( MBHEX, conn[i], 8, elements[i] );CHECK_ERR( rval );
1918  }
1919 
1920  // delete some stuff so there are multiple sequences
1921  rval = mb.delete_entities( elements + 2, 2 );CHECK_ERR( rval );
1922  Range::iterator i = vertex_handles.begin();
1923  i += 16;
1924  rval = mb.delete_entities( &*i, 1 );CHECK_ERR( rval );
1925  i += 2;
1926  rval = mb.delete_entities( &*i, 1 );CHECK_ERR( rval );
1927 }

References moab::Range::begin(), CHECK_EQUAL, CHECK_ERR, moab::Core::create_element(), moab::Core::create_vertices(), moab::Core::delete_entities(), ErrorCode, mb, 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().

◆ test_bit_tag_big()

void test_bit_tag_big ( )

Definition at line 1827 of file TagTest.cpp.

1828 {
1829  Core moab;
1830  Interface& mb = moab;
1831  ErrorCode rval;
1832  const size_t NUM_VTX = 30000;
1833 
1834  // create a lot of vertices
1835  std::vector< double > coords( 3 * NUM_VTX, 0.0 );
1836  Range verts;
1837  rval = mb.create_vertices( &coords[0], NUM_VTX, verts );CHECK_ERR( rval );
1838  CHECK_EQUAL( NUM_VTX, (size_t)verts.size() );
1839 
1840  // create a bit tag
1841  Tag tag = test_create_tag( mb, "bb", 4, MB_TAG_BIT, MB_TYPE_BIT, 0 );
1842  // for each vertex, store last four bits of handle as tag value
1843  std::vector< unsigned char > values( NUM_VTX );
1844  std::vector< unsigned char >::iterator it = values.begin();
1845  for( Range::iterator j = verts.begin(); j != verts.end(); ++j, ++it )
1846  *it = (unsigned char)( *j & 0xF );
1847  rval = mb.tag_set_data( tag, verts, &values[0] );CHECK_ERR( rval );
1848 
1849  // retrieve values
1850  std::vector< unsigned char > values2( NUM_VTX, 0 );
1851  rval = mb.tag_get_data( tag, verts, &values2[0] );
1852  CHECK_EQUAL( values, values2 );
1853 
1854  // retrieve individual values
1855  it = values.begin();
1856  for( Range::iterator j = verts.begin(); j != verts.end(); ++j, ++it )
1857  {
1858  char value;
1859  rval = mb.tag_get_data( tag, &*j, 1, &value );CHECK_ERR( rval );
1860  CHECK_EQUAL( *it, value );
1861  }
1862 
1863  // retrieve entities
1864  unsigned char value = 0xC;
1865  Range expected, results;
1866  for( Range::reverse_iterator j = verts.rbegin(); j != verts.rend(); ++j )
1867  if( (unsigned char)( *j & 0xF ) == value ) expected.insert( *j );
1868  const void* vals[] = { &value };
1869  rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, vals, 1, results );CHECK_ERR( rval );
1870  CHECK_EQUAL( expected, results );
1871 
1872  // test singe-bit tag
1873  Tag tag1 = test_create_tag( mb, "bb1", 1, MB_TAG_BIT, MB_TYPE_BIT, 0 );
1874  // set tag to 1 on all vertices
1875  values.clear();
1876  values.resize( NUM_VTX, '\001' );
1877  rval = mb.tag_set_data( tag1, verts, &values[0] );CHECK_ERR( rval );
1878  // retrieve values individually
1879  for( Range::iterator j = verts.begin(); j != verts.end(); ++j )
1880  {
1881  char cvalue;
1882  rval = mb.tag_get_data( tag1, &*j, 1, &cvalue );CHECK_ERR( rval );
1883  CHECK_EQUAL( 1, (int)cvalue );
1884  }
1885  // clear values individually
1886  for( Range::iterator j = verts.begin(); j != verts.end(); ++j )
1887  {
1888  char cvalue = '\0';
1889  rval = mb.tag_set_data( tag1, &*j, 1, &cvalue );CHECK_ERR( rval );
1890  }
1891  // retrieve values using range
1892  rval = mb.tag_get_data( tag1, verts, &values[0] );CHECK_ERR( rval );
1893  size_t first_one = std::find( values.begin(), values.end(), '\001' ) - values.begin();
1894  CHECK_EQUAL( values.size(), first_one );
1895 }

References moab::Range::begin(), CHECK_EQUAL, CHECK_ERR, moab::Core::create_vertices(), moab::Range::end(), ErrorCode, moab::Core::get_entities_by_type_and_tag(), moab::Range::insert(), mb, MB_TAG_BIT, MB_TYPE_BIT, MBVERTEX, moab::Range::rbegin(), moab::Range::rend(), moab::Range::size(), moab::Core::tag_get_data(), moab::Core::tag_set_data(), and test_create_tag().

Referenced by main().

◆ test_clear_bit()

void test_clear_bit ( )

Definition at line 808 of file TagTest.cpp.

809 {
810  // create mesh and tag
811  Core moab;
812  Interface& mb = moab;
813  setup_mesh( mb );
814  Tag tag = test_create_tag( mb, "clear_bit_val", 2, MB_TAG_BIT, MB_TYPE_BIT, 0 );
815 
816  // get some handles to work with
817  Range entities;
818  ErrorCode rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
819  CHECK( !entities.empty() );
820 
821  const unsigned char bits = 2;
822  rval = mb.tag_clear_data( tag, entities, &bits );CHECK_ERR( rval );
823 
824  // set bits on every entity
825  for( Range::iterator i = entities.begin(); i != entities.end(); ++i )
826  {
827  unsigned char bits_out = 0;
828  rval = mb.tag_get_data( tag, &*i, 1, &bits_out );
829  CHECK_EQUAL( bits, bits_out );
830  }
831 }

References CHECK, CHECK_EQUAL, CHECK_ERR, entities, ErrorCode, moab::Core::get_entities_by_handle(), mb, MB_TAG_BIT, MB_TYPE_BIT, setup_mesh(), moab::Core::tag_clear_data(), moab::Core::tag_get_data(), and test_create_tag().

Referenced by main().

◆ test_clear_dense()

void test_clear_dense ( )

Definition at line 734 of file TagTest.cpp.

735 {
736  const int int_val = 0xcab;
737  test_get_set( "clear_dense_int", 1, MB_TAG_DENSE, MB_TYPE_INTEGER, &int_val, 1, 0, ONE_VALUE, false );
738 
739  const double dbl_val[] = { 3.14159, -3.14159 };
740  const double default_val[] = { -2, 5 };
741  test_get_set( "clear_dense_double", 2, MB_TAG_DENSE, MB_TYPE_DOUBLE, &dbl_val, 1, default_val, ONE_VALUE, false );
742 }

References MB_TAG_DENSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, ONE_VALUE, and test_get_set().

Referenced by main().

◆ test_clear_dense_varlen()

void test_clear_dense_varlen ( )

Definition at line 1746 of file TagTest.cpp.

1747 {
1748  test_clear_variable_length( MB_TAG_DENSE );
1749 }

References MB_TAG_DENSE, and test_clear_variable_length().

Referenced by main().

◆ test_clear_sparse()

void test_clear_sparse ( )

Definition at line 744 of file TagTest.cpp.

745 {
746  const int int_val = 0xcab;
747  test_get_set( "clear_sparse_int", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, &int_val, 1, 0, ONE_VALUE, false );
748 
749  const double dbl_val[] = { 3.14159, -3.14159 };
750  const double default_val[] = { -2, 5 };
751  test_get_set( "clear_sparse_double", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, &dbl_val, 1, default_val, ONE_VALUE, false );
752 }

References MB_TAG_SPARSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, ONE_VALUE, and test_get_set().

Referenced by main().

◆ test_clear_sparse_varlen()

void test_clear_sparse_varlen ( )

Definition at line 1741 of file TagTest.cpp.

1742 {
1743  test_clear_variable_length( MB_TAG_SPARSE );
1744 }

References MB_TAG_SPARSE, and test_clear_variable_length().

Referenced by main().

◆ test_clear_variable_length()

void test_clear_variable_length ( TagType  storage)

Definition at line 1726 of file TagTest.cpp.

1727 {
1728  const double doubles[3] = { 1e-1, 1e-2, 1e-3 };
1729  const void* dvals[] = { doubles };
1730  const int dlen = sizeof( doubles ) / sizeof( double );
1731  test_get_set_variable_length( "vnodef_clear", storage, MB_TYPE_DOUBLE, dvals, &dlen, 1, 0, 0 );
1732 
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 };
1738  test_get_set_variable_length( "vdef_clear", storage, MB_TYPE_INTEGER, ivals, &ilen, 1, defvals, 4 );
1739 }

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().

◆ test_create_tag() [1/2]

void test_create_tag ( )

Definition at line 297 of file TagTest.cpp.

298 {
299  Core mb;
300  unsigned char defval[] = { 1, 2, 3, 4, 0, 0, 0, 0 };
301 
302  // opaque tags
303  test_create_tag( mb, "opaque_tag_sparse", 8, MB_TAG_SPARSE, MB_TYPE_OPAQUE, defval );
304  test_create_tag( mb, "opaque_tag_dense", 4, MB_TAG_DENSE, MB_TYPE_OPAQUE, defval );
305  test_create_tag( mb, "opaque_tag_dense2", 1, MB_TAG_DENSE, MB_TYPE_OPAQUE, 0 );
306 
307  // integer tags
308  test_create_tag( mb, "int_tag_sparse", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, defval );
309  test_create_tag( mb, "int_tag_dense", 8, MB_TAG_DENSE, MB_TYPE_INTEGER, 0 );
310 
311  // double tags
312  double defval2[] = { 3.14159, 2.71828 };
313  test_create_tag( mb, "dbl_tag_sparse", 1, MB_TAG_SPARSE, MB_TYPE_DOUBLE, 0 );
314  test_create_tag( mb, "dbl_tag_dense", 2, MB_TAG_DENSE, MB_TYPE_DOUBLE, defval2 );
315 
316  // handle tags
317  test_create_tag( mb, "h_tag_dense", 1, MB_TAG_DENSE, MB_TYPE_HANDLE, defval );
318 
319  // bit tags
320  unsigned char def_bit_val = 0xBF;
321  test_create_tag( mb, "bit_tag_1", 2, MB_TAG_BIT, MB_TYPE_BIT, &def_bit_val );
322 }

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().

◆ test_create_tag() [2/2]

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.

155 {
156  ErrorCode rval;
157  Tag tag;
158 
159  rval = mb.tag_get_handle( name, num_vals, type, tag, storage | MB_TAG_EXCL, defval );
160  if( expect != MB_SUCCESS )
161  {
162  CHECK_EQUAL( expect, rval );
163  return 0;
164  }
165  CHECK_ERR( rval );
166 
167  std::string n;
168  rval = mb.tag_get_name( tag, n );CHECK_ERR( rval );
169  CHECK( n == name );
170 
171  Tag tag2;
172  rval = mb.tag_get_handle( name, num_vals, type, tag2 );CHECK_ERR( rval );
173  CHECK_EQUAL( tag, tag2 );
174 
175  int s;
176  rval = mb.tag_get_length( tag, s );CHECK_ERR( rval );
177  CHECK_EQUAL( num_vals, s );
178 
179  TagType t;
180  rval = mb.tag_get_type( tag, t );CHECK_ERR( rval );
181  CHECK_EQUAL( storage, t );
182 
183  DataType d;
184  rval = mb.tag_get_data_type( tag, d );CHECK_ERR( rval );
185  CHECK_EQUAL( type, d );
186 
187  int bytes;
188  rval = mb.tag_get_bytes( tag, bytes );CHECK_ERR( rval );
189  int exp_bytes = 0;
190  switch( type )
191  {
192  case MB_TYPE_INTEGER:
193  exp_bytes = num_vals * sizeof( int );
194  break;
195  case MB_TYPE_DOUBLE:
196  exp_bytes = num_vals * sizeof( double );
197  break;
198  case MB_TYPE_HANDLE:
199  exp_bytes = num_vals * sizeof( EntityHandle );
200  break;
201  case MB_TYPE_BIT:
202  exp_bytes = 1;
203  break;
204  case MB_TYPE_OPAQUE:
205  exp_bytes = num_vals;
206  break;
207  }
208  CHECK_EQUAL( exp_bytes, bytes );
209 
210  std::vector< unsigned char > defv( bytes );
211  rval = mb.tag_get_default_value( tag, &defv[0] );
212  if( defval )
213  {
214  CHECK_ERR( rval );
215  CHECK( !memcmp( defval, &defv[0], bytes ) );
216  }
217  else
218  {
219  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
220  }
221 
222  // make sure we can't create a second tag w/ the same name
223  rval = mb.tag_get_handle( name, num_vals, type, tag2, storage | MB_TAG_EXCL, defval );
224  CHECK_EQUAL( MB_ALREADY_ALLOCATED, rval );
225  // we should get back the handle of the existing tag
226  CHECK_EQUAL( tag, tag2 );
227 
228  return tag;
229 }

References CHECK, CHECK_EQUAL, CHECK_ERR, ErrorCode, mb, 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::Core::tag_get_bytes(), moab::Core::tag_get_data_type(), moab::Core::tag_get_default_value(), moab::Core::tag_get_handle(), moab::Core::tag_get_length(), moab::Core::tag_get_name(), moab::Core::tag_get_type(), and TagType.

◆ test_create_var_len_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.

238 {
239  ErrorCode rval;
240  Tag tag;
241 
242  rval = mb.tag_get_handle( name, defval_size, type, tag, storage | MB_TAG_VARLEN | MB_TAG_EXCL, defval );
243  if( expect != MB_SUCCESS )
244  {
245  CHECK_EQUAL( expect, rval );
246  return 0;
247  }
248  CHECK_ERR( rval );
249 
250  std::string n;
251  rval = mb.tag_get_name( tag, n );CHECK_ERR( rval );
252  CHECK( n == name );
253 
254  Tag tag2;
255  rval = mb.tag_get_handle( name, 0, type, tag2 );CHECK_ERR( rval );
256  CHECK_EQUAL( tag, tag2 );
257 
258  int s;
259  rval = mb.tag_get_bytes( tag, s );
260  CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, rval );
261  rval = mb.tag_get_length( tag, s );
262  CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, rval );
263  // CHECK_ERR(rval);
264  // CHECK_EQUAL( MB_VARIABLE_LENGTH, s );
265 
266  TagType t;
267  rval = mb.tag_get_type( tag, t );CHECK_ERR( rval );
268  CHECK_EQUAL( storage, t );
269 
270  DataType d;
271  rval = mb.tag_get_data_type( tag, d );CHECK_ERR( rval );
272  CHECK_EQUAL( type, d );
273 
274  int size;
275  const void* defv;
276  rval = mb.tag_get_default_value( tag, defv, size );
277  if( defval )
278  {
279  CHECK_ERR( rval );
280  CHECK_EQUAL( defval_size, size );
281  CHECK( !memcmp( defval, defv, size ) );
282  }
283  else
284  {
285  CHECK_EQUAL( MB_ENTITY_NOT_FOUND, rval );
286  }
287 
288  // make sure we can't create a second tag w/ the same name
289  rval = mb.tag_get_handle( name, defval_size, type, tag2, storage | MB_TAG_VARLEN | MB_TAG_EXCL );
290  CHECK_EQUAL( MB_ALREADY_ALLOCATED, rval );
291  // we should get back the handle of the existing tag
292  CHECK_EQUAL( tag, tag2 );
293 
294  return tag;
295 }

References CHECK, CHECK_EQUAL, CHECK_ERR, ErrorCode, mb, MB_ALREADY_ALLOCATED, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TAG_EXCL, MB_TAG_VARLEN, MB_VARIABLE_DATA_LENGTH, size, t, moab::Core::tag_get_bytes(), moab::Core::tag_get_data_type(), moab::Core::tag_get_default_value(), moab::Core::tag_get_handle(), moab::Core::tag_get_length(), moab::Core::tag_get_name(), moab::Core::tag_get_type(), and TagType.

Referenced by test_create_variable_length_tag(), test_get_set_variable_length(), and test_get_set_variable_length_mesh().

◆ test_create_variable_length_tag()

void test_create_variable_length_tag ( )

Definition at line 324 of file TagTest.cpp.

325 {
326  Core mb;
327  unsigned char defval[] = { 1, 2, 3, 4, 0, 0, 0, 0 };
328 
329  // opaque tags
330  const void* defptr = defval;
331  test_create_var_len_tag( mb, "opaque_tag_sparse", MB_TAG_SPARSE, MB_TYPE_OPAQUE, defptr, 8 );
332  test_create_var_len_tag( mb, "opaque_tag_dense", MB_TAG_DENSE, MB_TYPE_OPAQUE, defptr, 4 );
333  test_create_var_len_tag( mb, "opaque_tag_dense2", MB_TAG_DENSE, MB_TYPE_OPAQUE, 0, 0 );
334 
335  // integer tags
336  test_create_var_len_tag( mb, "int_tag_sparse", MB_TAG_SPARSE, MB_TYPE_INTEGER, defptr, 1 );
337  test_create_var_len_tag( mb, "int_tag_dense", MB_TAG_DENSE, MB_TYPE_INTEGER, 0, 0 );
338 
339  // double tags
340  double defval2[] = { 3.14159, 2.71828 };
341  defptr = defval2;
342  test_create_var_len_tag( mb, "dbl_tag_sparse", MB_TAG_SPARSE, MB_TYPE_DOUBLE, 0, 0 );
343  test_create_var_len_tag( mb, "dbl_tag_dense", MB_TAG_DENSE, MB_TYPE_DOUBLE, defptr, 2 );
344 
345  // handle tags
346  test_create_var_len_tag( mb, "h_tag_dense", MB_TAG_DENSE, MB_TYPE_HANDLE, 0, 0 );
347 }

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().

◆ test_delete_bit_data()

void test_delete_bit_data ( )

Definition at line 1405 of file TagTest.cpp.

1406 {
1407  Core moab;
1408  Interface& mb = moab;
1409  ErrorCode rval;
1410 
1411  // get an entity to set data on
1412  setup_mesh( mb );
1413  Range entities;
1414  rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
1415  CHECK( !entities.empty() );
1416  EntityHandle handle = entities.front();
1417 
1418  // create two tags, one with a default value and one without
1419  unsigned char defval = '\006'; // 110
1420  Tag tag1, tag2;
1421  tag1 = test_create_tag( mb, "tag1", 2, MB_TAG_BIT, MB_TYPE_BIT, 0 );
1422  tag2 = test_create_tag( mb, "tag2", 3, MB_TAG_BIT, MB_TYPE_BIT, &defval );
1423 
1424  // set value for each tag
1425  unsigned char val = '\001';
1426  rval = mb.tag_set_data( tag1, &handle, 1, &val );CHECK_ERR( rval );
1427  rval = mb.tag_set_data( tag2, &handle, 1, &val );CHECK_ERR( rval );
1428 
1429  // delete both tag values
1430  rval = mb.tag_delete_data( tag1, &handle, 1 );CHECK_ERR( rval );
1431  rval = mb.tag_delete_data( tag2, &handle, 1 );CHECK_ERR( rval );
1432 
1433  // try to get value for tag w/out default.
1434  // should get back either not found, or a zero value.
1435  val = 0xFF;
1436  rval = mb.tag_get_data( tag1, &handle, 1, &val );
1437  if( MB_SUCCESS == rval )
1438  CHECK_EQUAL( val, '\0' );
1439  else
1440  CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
1441 
1442  // test that we get back default value for second tag
1443  val = 0xFF;
1444  rval = mb.tag_get_data( tag2, &handle, 1, &val );CHECK_ERR( rval );
1445  CHECK_EQUAL( defval, val );
1446 }

References CHECK, CHECK_EQUAL, CHECK_ERR, entities, ErrorCode, moab::Core::get_entities_by_handle(), mb, MB_SUCCESS, MB_TAG_BIT, MB_TAG_NOT_FOUND, MB_TYPE_BIT, setup_mesh(), moab::Core::tag_delete_data(), moab::Core::tag_get_data(), moab::Core::tag_set_data(), and test_create_tag().

Referenced by main().

◆ test_delete_dense_data()

void test_delete_dense_data ( )

Definition at line 1399 of file TagTest.cpp.

1400 {
1401  test_delete_tag_data( MB_TAG_SPARSE, false );
1402  test_delete_tag_data( MB_TAG_SPARSE, true );
1403 }

References MB_TAG_SPARSE, and test_delete_tag_data().

Referenced by main().

◆ test_delete_dense_tag()

void test_delete_dense_tag ( )

Definition at line 1286 of file TagTest.cpp.

1287 {
1288  test_delete_type_tag( MB_TAG_DENSE );
1289 }

References MB_TAG_DENSE, and test_delete_type_tag().

Referenced by main().

◆ test_delete_mesh_tag()

void test_delete_mesh_tag ( )

Definition at line 1291 of file TagTest.cpp.

1292 {
1293  test_delete_type_tag( MB_TAG_MESH );
1294 }

References MB_TAG_MESH, and test_delete_type_tag().

Referenced by main().

◆ test_delete_sparse_data()

void test_delete_sparse_data ( )

Definition at line 1393 of file TagTest.cpp.

1394 {
1395  test_delete_tag_data( MB_TAG_DENSE, false );
1396  test_delete_tag_data( MB_TAG_DENSE, true );
1397 }

References MB_TAG_DENSE, and test_delete_tag_data().

Referenced by main().

◆ test_delete_sparse_tag()

void test_delete_sparse_tag ( )

Definition at line 1281 of file TagTest.cpp.

1282 {
1283  test_delete_type_tag( MB_TAG_SPARSE );
1284 }

References MB_TAG_SPARSE, and test_delete_type_tag().

Referenced by main().

◆ test_delete_tag_data()

void test_delete_tag_data ( TagType  storage,
bool  with_default_value 
)

Definition at line 1296 of file TagTest.cpp.

1297 {
1298  Core moab;
1299  Interface& mb = moab;
1300  ErrorCode rval;
1301 
1302  setup_mesh( mb );
1303 
1304  // subdivide entity handles into three groups:
1305  // 1) entities for which the tag data will be deleted using the array-based function
1306  // 2) entities for which the tag data will be deleted using the range-based function
1307  // 3) entities for which the tag data will not be deleted
1308  Range all_entities, del1_range, keep_range;
1309  std::vector< EntityHandle > del1_list, del2_list, keep_list;
1310  rval = mb.get_entities_by_handle( 0, all_entities );CHECK_ERR( rval );
1311  int c = 0;
1312  for( Range::iterator i = all_entities.begin(); i != all_entities.end(); ++i, ++c )
1313  {
1314  switch( c % 3 )
1315  {
1316  case 0:
1317  del1_range.insert( *i );
1318  break;
1319  case 1:
1320  keep_range.insert( *i );
1321  break;
1322  case 2:
1323  del2_list.push_back( *i );
1324  break;
1325  }
1326  }
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() );
1331 
1332  // create tag
1333  EntityHandle first = all_entities.front();
1334  EntityHandle* defval = with_default_value ? &first : 0;
1335  const char* tagname = "dead_tag";
1336  Tag tag = test_create_tag( mb, tagname, 1, storage, MB_TYPE_HANDLE, defval );
1337 
1338  // set value for each entity to its handle
1339  rval = mb.tag_set_data( tag, del1_range, &del1_list[0] );CHECK_ERR( rval );
1340  rval = mb.tag_set_data( tag, keep_range, &keep_list[0] );CHECK_ERR( rval );
1341  rval = mb.tag_set_data( tag, &del2_list[0], del2_list.size(), &del2_list[0] );CHECK_ERR( rval );
1342 
1343  // delete tag data
1344  rval = mb.tag_delete_data( tag, del1_range );CHECK_ERR( rval );
1345  rval = mb.tag_delete_data( tag, &del2_list[0], del2_list.size() );CHECK_ERR( rval );
1346 
1347  // test that keep list is unaffected
1348  std::vector< EntityHandle > tag_data( keep_range.size(), 0 );
1349  rval = mb.tag_get_data( tag, keep_range, &tag_data[0] );CHECK_ERR( rval );
1350  CHECK( tag_data == keep_list );
1351 
1352  // try to get data for deleted range
1353  tag_data.clear();
1354  tag_data.resize( del1_range.size(), (EntityHandle)-1 );
1355  rval = mb.tag_get_data( tag, del1_range, &tag_data[0] );
1356  // if we have a default value, should get that for deleted entities
1357  if( with_default_value )
1358  {
1359  CHECK_ERR( rval );
1360  std::vector< EntityHandle > expected( del1_range.size(), *defval );
1361  CHECK( expected == tag_data );
1362  }
1363  else if( rval != MB_TAG_NOT_FOUND )
1364  {
1365  // dense and bit tags might return either MB_TAG_NOT_FOUND or zero bytes.
1366  // sparse tags should always return MB_TAG_NOT_FOUND
1367  CHECK( MB_TAG_SPARSE != storage );
1368  std::vector< EntityHandle > expected( del1_range.size(), 0 );
1369  CHECK( expected == tag_data );
1370  }
1371 
1372  // try to get data for deleted list
1373  tag_data.clear();
1374  tag_data.resize( del1_range.size(), (EntityHandle)-1 );
1375  rval = mb.tag_get_data( tag, del1_range, &tag_data[0] );
1376  // if we have a default value, should get that for deleted entities
1377  if( with_default_value )
1378  {
1379  CHECK_ERR( rval );
1380  std::vector< EntityHandle > expected( del1_range.size(), *defval );
1381  CHECK( expected == tag_data );
1382  }
1383  else if( rval != MB_TAG_NOT_FOUND )
1384  {
1385  // dense and bit tags might return either MB_TAG_NOT_FOUND or zero bytes.
1386  // sparse tags should always return MB_TAG_NOT_FOUND
1387  CHECK( MB_TAG_SPARSE != storage );
1388  std::vector< EntityHandle > expected( del1_range.size(), 0 );
1389  CHECK( expected == tag_data );
1390  }
1391 }

References moab::Range::begin(), CHECK, CHECK_ERR, moab::Range::end(), ErrorCode, moab::GeomUtil::first(), moab::Range::front(), moab::Core::get_entities_by_handle(), moab::Range::insert(), mb, MB_TAG_NOT_FOUND, MB_TAG_SPARSE, MB_TYPE_HANDLE, setup_mesh(), moab::Range::size(), moab::Core::tag_delete_data(), moab::Core::tag_get_data(), moab::Core::tag_set_data(), tagname, and test_create_tag().

Referenced by test_delete_dense_data(), and test_delete_sparse_data().

◆ test_delete_type_tag()

static void test_delete_type_tag ( TagType  storage)
static

Definition at line 1101 of file TagTest.cpp.

1102 {
1103  Core moab;
1104  Interface& mb = moab;
1105  ErrorCode rval;
1106 
1107  setup_mesh( mb );
1108 
1109  // create tag
1110  int default_val = 42;
1111  const char* tagname = "dead_tag";
1112  Tag tag = test_create_tag( mb, tagname, 1, storage, MB_TYPE_INTEGER, &default_val );
1113 
1114  // get an entity handle to work with
1115  Range verts;
1116  rval = mb.get_entities_by_type( 0, MBVERTEX, verts );CHECK_ERR( rval );
1117  CHECK( !verts.empty() );
1118  EntityHandle handle = verts.front();
1119 
1120  // set tag value on entity
1121  int value = -5;
1122  if( storage != MB_TAG_MESH )
1123  {
1124  rval = mb.tag_set_data( tag, &handle, 1, &value );CHECK_ERR( rval );
1125  }
1126 
1127  // set tag value on mesh
1128  const EntityHandle mesh = 0;
1129  value = 2;
1130  rval = mb.tag_set_data( tag, &mesh, 1, &value );CHECK_ERR( rval );
1131 
1132  // delete tag
1133  rval = mb.tag_delete( tag );CHECK_ERR( rval );
1134 
1135  // make sure all basic queries fail with MB_TAG_NOT_FOUND
1136  std::string name;
1137  rval = mb.tag_get_name( tag, name );
1138  CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
1139  Tag tag2;
1140  rval = mb.tag_get_handle( tagname, 1, MB_TYPE_INTEGER, tag2 );
1141  CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
1142  int size;
1143  rval = mb.tag_get_bytes( tag, size );
1144  CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
1145  rval = mb.tag_get_length( tag, size );
1146  CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
1147  // get get the type from the handle, so this still succeeds
1148  // TagType storage2;
1149  // rval = mb.tag_get_type( tag, storage2 );
1150  // CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
1151  DataType type;
1152  rval = mb.tag_get_data_type( tag, type );
1153  CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
1154  rval = mb.tag_get_default_value( tag, &value );
1155  CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
1156 
1157  // check global list of tags
1158  std::vector< Tag > tags;
1159  rval = mb.tag_get_tags( tags );CHECK_ERR( rval );
1160  CHECK( std::find( tags.begin(), tags.end(), tag ) == tags.end() );
1161 
1162  // check tags on entity
1163  tags.clear();
1164  rval = mb.tag_get_tags_on_entity( handle, tags );CHECK_ERR( rval );
1165  CHECK( std::find( tags.begin(), tags.end(), tag ) == tags.end() );
1166 
1167  // check that a new tag w/ the same name can be created
1168  tag = test_create_tag( mb, tagname, 1, storage, MB_TYPE_DOUBLE, 0 );
1169  rval = mb.tag_delete( tag );CHECK_ERR( rval );
1170 }

References CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::empty(), ErrorCode, moab::Range::front(), moab::Core::get_entities_by_type(), mb, MB_TAG_MESH, MB_TAG_NOT_FOUND, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, MBVERTEX, mesh, setup_mesh(), size, moab::Core::tag_delete(), moab::Core::tag_get_bytes(), moab::Core::tag_get_data_type(), moab::Core::tag_get_default_value(), moab::Core::tag_get_handle(), moab::Core::tag_get_length(), moab::Core::tag_get_name(), moab::Core::tag_get_tags(), moab::Core::tag_get_tags_on_entity(), moab::Core::tag_set_data(), tagname, and test_create_tag().

Referenced by test_delete_dense_tag(), test_delete_mesh_tag(), and test_delete_sparse_tag().

◆ test_get_by_tag()

void test_get_by_tag ( )

Definition at line 833 of file TagTest.cpp.

834 {
835  // create mesh and tag
836  Core moab;
837  Interface& mb = moab;
838  setup_mesh( mb );
839  Tag tag = test_create_tag( mb, "sparse_count", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, 0 );
840 
841  // get some handles to work with
842  Range entities;
843  ErrorCode rval = mb.get_entities_by_type( 0, MBVERTEX, entities );CHECK_ERR( rval );
844  CHECK( !entities.empty() );
845 
846  // get five handles
847  CHECK( entities.size() > 6 );
848  EntityHandle arr[5] = { *( entities.begin() += entities.size() / 6 ),
849  *( entities.begin() += 2 * entities.size() / 6 ),
850  *( entities.begin() += 3 * entities.size() / 6 ),
851  *( entities.begin() += 4 * entities.size() / 6 ),
852  *( entities.begin() += 5 * entities.size() / 6 ) };
853  int values[5] = { 1, 2, 3, 4, 5 };
854  rval = mb.tag_set_data( tag, arr, 5, values );CHECK_ERR( rval );
855  const void* const valarr[1] = { 0 };
856 
857  // put some in a mesh set
858  EntityHandle set;
859  const int num_in_set = 3;
860  rval = mb.create_meshset( 0, set );CHECK_ERR( rval );
861  rval = mb.add_entities( set, arr, num_in_set );CHECK_ERR( rval );
862 
863  // try for whole mesh will null tag value array
864  int count = -1;
865  rval = mb.get_number_entities_by_type_and_tag( 0, MBVERTEX, &tag, 0, 1, count );CHECK_ERR( rval );
866  CHECK_EQUAL( 5, count );
867 
868  // try for whole mesh will null tag value, but non-null array
869  count = -1;
870  rval = mb.get_number_entities_by_type_and_tag( 0, MBVERTEX, &tag, valarr, 1, count );CHECK_ERR( rval );
871  CHECK_EQUAL( 5, count );
872 
873  // try for mesh set
874  rval = mb.get_number_entities_by_type_and_tag( set, MBVERTEX, &tag, 0, 1, count );CHECK_ERR( rval );
875  CHECK_EQUAL( num_in_set, count );
876 
877  // try for whole mesh will null tag value array
878  Range found;
879  rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, 0, 1, found );CHECK_ERR( rval );
880  CHECK_EQUAL( 5u, (unsigned)found.size() );
881  Range::iterator i = found.begin();
882  CHECK_EQUAL( arr[0], *i );
883  ++i;
884  CHECK_EQUAL( arr[1], *i );
885  ++i;
886  CHECK_EQUAL( arr[2], *i );
887  ++i;
888  CHECK_EQUAL( arr[3], *i );
889  ++i;
890  CHECK_EQUAL( arr[4], *i );
891 
892  // try for whole mesh will null tag value, but non-null array
893  found.clear();
894  rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, valarr, 1, found );CHECK_ERR( rval );
895  CHECK_EQUAL( 5u, (unsigned)found.size() );
896  i = found.begin();
897  CHECK_EQUAL( arr[0], *i );
898  ++i;
899  CHECK_EQUAL( arr[1], *i );
900  ++i;
901  CHECK_EQUAL( arr[2], *i );
902  ++i;
903  CHECK_EQUAL( arr[3], *i );
904  ++i;
905  CHECK_EQUAL( arr[4], *i );
906 
907  // try for mesh set
908  found.clear();
909  rval = mb.get_entities_by_type_and_tag( set, MBVERTEX, &tag, 0, 1, found );CHECK_ERR( rval );
910  CHECK_EQUAL( 3u, (unsigned)found.size() );
911  i = found.begin();
912  CHECK_EQUAL( arr[0], *i );
913  ++i;
914  CHECK_EQUAL( arr[1], *i );
915  ++i;
916  CHECK_EQUAL( arr[2], *i );
917 }

References moab::Core::add_entities(), moab::Range::begin(), CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::clear(), moab::Core::create_meshset(), entities, ErrorCode, moab::Core::get_entities_by_type(), moab::Core::get_entities_by_type_and_tag(), moab::Core::get_number_entities_by_type_and_tag(), mb, MB_TAG_SPARSE, MB_TYPE_INTEGER, MBVERTEX, setup_mesh(), moab::Range::size(), moab::Core::tag_set_data(), and test_create_tag().

Referenced by main().

◆ test_get_by_tag_value()

void test_get_by_tag_value ( )

Definition at line 919 of file TagTest.cpp.

920 {
921  // create mesh and tag
922  Core moab;
923  Interface& mb = moab;
924  setup_mesh( mb );
925  Tag tag = test_create_tag( mb, "sparse_count", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, 0 );
926 
927  // get some handles to work with
928  Range entities;
929  ErrorCode rval = mb.get_entities_by_type( 0, MBVERTEX, entities );CHECK_ERR( rval );
930  CHECK( !entities.empty() );
931 
932  // get five handles
933  CHECK( entities.size() > 6 );
934  EntityHandle arr[5] = { *( entities.begin() += entities.size() / 6 ),
935  *( entities.begin() += 2 * entities.size() / 6 ),
936  *( entities.begin() += 3 * entities.size() / 6 ),
937  *( entities.begin() += 4 * entities.size() / 6 ),
938  *( entities.begin() += 5 * entities.size() / 6 ) };
939  int values[5] = { 0xBEEF, 0xBEEF, 0xBEEF, 0xBEEF, 0xBEEF };
940  rval = mb.tag_set_data( tag, arr, 5, values );CHECK_ERR( rval );
941  const void* const valarr[1] = { values };
942 
943  // put some in a mesh set
944  EntityHandle set;
945  const int num_in_set = 3;
946  rval = mb.create_meshset( 0, set );CHECK_ERR( rval );
947  rval = mb.add_entities( set, arr, num_in_set );CHECK_ERR( rval );
948 
949  // try for whole mesh
950  int count = -1;
951  rval = mb.get_number_entities_by_type_and_tag( 0, MBVERTEX, &tag, valarr, 1, count );CHECK_ERR( rval );
952  CHECK_EQUAL( 5, count );
953 
954  // try for mesh set
955  rval = mb.get_number_entities_by_type_and_tag( set, MBVERTEX, &tag, valarr, 1, count );CHECK_ERR( rval );
956  CHECK_EQUAL( num_in_set, count );
957 
958  // try for whole mesh
959  Range found;
960  rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, valarr, 1, found );CHECK_ERR( rval );
961  CHECK_EQUAL( 5u, (unsigned)found.size() );
962  Range::iterator i = found.begin();
963  CHECK_EQUAL( arr[0], *i );
964  ++i;
965  CHECK_EQUAL( arr[1], *i );
966  ++i;
967  CHECK_EQUAL( arr[2], *i );
968  ++i;
969  CHECK_EQUAL( arr[3], *i );
970  ++i;
971  CHECK_EQUAL( arr[4], *i ); //++i;
972 
973  // try for mesh set
974  found.clear();
975  rval = mb.get_entities_by_type_and_tag( set, MBVERTEX, &tag, valarr, 1, found );CHECK_ERR( rval );
976  CHECK_EQUAL( 3u, (unsigned)found.size() );
977  i = found.begin();
978  CHECK_EQUAL( arr[0], *i );
979  ++i;
980  CHECK_EQUAL( arr[1], *i );
981  ++i;
982  CHECK_EQUAL( arr[2], *i ); //++i;
983 }

References moab::Core::add_entities(), moab::Range::begin(), CHECK, CHECK_EQUAL, CHECK_ERR, moab::Range::clear(), moab::Core::create_meshset(), entities, ErrorCode, moab::Core::get_entities_by_type(), moab::Core::get_entities_by_type_and_tag(), moab::Core::get_number_entities_by_type_and_tag(), mb, MB_TAG_SPARSE, MB_TYPE_INTEGER, MBVERTEX, setup_mesh(), moab::Range::size(), moab::Core::tag_set_data(), and test_create_tag().

Referenced by main().

◆ test_get_by_tag_value_dense()

void test_get_by_tag_value_dense ( )

Definition at line 985 of file TagTest.cpp.

986 {
987  // create mesh and tag
988  ErrorCode rval;
989  Core moab;
990  Interface& mb = moab;
991  setup_mesh( mb );
992  const int def_val = 0xABCD;
993  const int fill_val = 0xBEEF;
994  const int find_val = 0xFEED;
995  Tag tag = test_create_tag( mb, "dense_gbv", 1, MB_TAG_DENSE, MB_TYPE_INTEGER, &def_val );
996 
997  // get some handles to work with
998  Range elements, vertices, results;
999  rval = mb.get_entities_by_type( 0, MBHEX, elements );CHECK_ERR( rval );
1000  rval = mb.get_entities_by_type( 0, MBVERTEX, vertices );CHECK_ERR( rval );
1001  CHECK( !elements.empty() );
1002 
1003  // set tag on all vertices to fill_val
1004  rval = mb.tag_clear_data( tag, vertices, &fill_val );CHECK_ERR( rval );
1005 
1006  // select three handles
1007  CHECK( elements.size() > 4 );
1008  EntityHandle arr[3] = { *( elements.begin() += elements.size() / 4 ),
1009  *( elements.begin() += 2 * elements.size() / 4 ),
1010  *( elements.begin() += 3 * elements.size() / 4 ) };
1011  int values[3] = { find_val, find_val, find_val };
1012  rval = mb.tag_set_data( tag, arr, 3, values );CHECK_ERR( rval );
1013 
1014  // get the entities tagged with 'find_val'
1015  const void* const findarr[1] = { &find_val };
1016  results.clear();
1017  rval = mb.get_entities_by_type_and_tag( 0, MBHEX, &tag, findarr, 1, results );CHECK_ERR( rval );
1018  CHECK_EQUAL( (size_t)3, results.size() );
1019  CHECK_EQUAL( arr[0], results.front() );
1020  CHECK_EQUAL( arr[1], *++results.begin() );
1021  CHECK_EQUAL( arr[2], results.back() );
1022 
1023  // should get no vertices
1024  results.clear();
1025  rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag, findarr, 1, results );CHECK_ERR( rval );
1026  CHECK( results.empty() );
1027 
1028  // try intersecting with an existing range
1029  results = elements;
1030  results.erase( arr[1] );
1031  results.insert( vertices.front() );
1032  rval = mb.get_entities_by_type_and_tag( 0, MBHEX, &tag, findarr, 1, results, Interface::INTERSECT );CHECK_ERR( rval );
1033  CHECK_EQUAL( (size_t)2, results.size() );
1034  CHECK_EQUAL( arr[0], results.front() );
1035  CHECK_EQUAL( arr[2], results.back() );
1036 
1037  // try getting entities with default value
1038  const void* const defarr[1] = { &def_val };
1039  results.clear();
1040  rval = mb.get_entities_by_type_and_tag( 0, MBHEX, &tag, defarr, 1, results );CHECK_ERR( rval );
1041  CHECK_EQUAL( elements.size() - 3, results.size() );
1042  Range expected( elements );
1043  expected.erase( arr[0] );
1044  expected.erase( arr[1] );
1045  expected.erase( arr[2] );
1046  CHECK( expected == results );
1047 }

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::Core::get_entities_by_type(), moab::Core::get_entities_by_type_and_tag(), moab::Range::insert(), moab::Interface::INTERSECT, mb, MB_TAG_DENSE, MB_TYPE_INTEGER, MBHEX, MBVERTEX, setup_mesh(), moab::Range::size(), moab::Core::tag_clear_data(), moab::Core::tag_set_data(), and test_create_tag().

Referenced by main().

◆ test_get_entity_tags()

void test_get_entity_tags ( )

Definition at line 1190 of file TagTest.cpp.

1191 {
1192  Core moab;
1193  Interface& mb = moab;
1194  ErrorCode rval;
1195 
1196  // get 8 handles to work with
1197  setup_mesh( mb );
1198  Range entities;
1199  rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
1200  CHECK( entities.size() >= 8 );
1201  Range::iterator i = entities.begin();
1202  EntityHandle sparse_ent = *i;
1203  ++i;
1204  EntityHandle dense_ent = *i;
1205  ++i;
1206  EntityHandle bit_ent = *i;
1207  ++i;
1208  EntityHandle sparse_dense_ent = *i;
1209  ++i;
1210  EntityHandle sparse_bit_ent = *i;
1211  ++i;
1212  EntityHandle dense_bit_ent = *i;
1213  ++i;
1214  EntityHandle all_tag_ent = *i;
1215  ++i;
1216  EntityHandle no_tag_ent = *i;
1217  ++i;
1218 
1219  // create three tags to work with
1220  Tag sparse, dense, bit;
1221  sparse = test_create_tag( mb, "sparse", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, 0 );
1222  dense = test_create_tag( mb, "dense_", 1, MB_TAG_DENSE, MB_TYPE_INTEGER, 0 );
1223  bit = test_create_tag( mb, "bit___", 1, MB_TAG_BIT, MB_TYPE_BIT, 0 );
1224 
1225  // set tags on handles
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 };
1230  rval = mb.tag_set_data( sparse, sparse_ents, 4, &values );CHECK_ERR( rval );
1231  rval = mb.tag_set_data( dense, dense_ents, 4, &values );CHECK_ERR( rval );
1232  for( int j = 0; j < 4; ++j )
1233  {
1234  unsigned char bitval = 0xF;
1235  rval = mb.tag_set_data( bit, bit_ents + j, 1, &bitval );CHECK_ERR( rval );
1236  }
1237 
1238  // get tags on each entity
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;
1241  rval = mb.tag_get_tags_on_entity( sparse_ent, sparse_ent_tags );CHECK_ERR( rval );
1242  rval = mb.tag_get_tags_on_entity( dense_ent, dense_ent_tags );CHECK_ERR( rval );
1243  rval = mb.tag_get_tags_on_entity( bit_ent, bit_ent_tags );CHECK_ERR( rval );
1244  rval = mb.tag_get_tags_on_entity( sparse_dense_ent, sparse_dense_ent_tags );CHECK_ERR( rval );
1245  rval = mb.tag_get_tags_on_entity( sparse_bit_ent, sparse_bit_ent_tags );CHECK_ERR( rval );
1246  rval = mb.tag_get_tags_on_entity( dense_bit_ent, dense_bit_ent_tags );CHECK_ERR( rval );
1247  rval = mb.tag_get_tags_on_entity( all_tag_ent, all_tag_ent_tags );CHECK_ERR( rval );
1248  rval = mb.tag_get_tags_on_entity( no_tag_ent, no_tag_ent_tags );CHECK_ERR( rval );
1249 
1250  // check expected values
1251  // NOTE: could potentially get back bit and dense tags for any entity
1252  // depending on the storage layout. Only sparse tags guarantee
1253  // no false positives. False negatives should never happen for any type.
1254  // Also, there could be other dense tags already defined.
1255 
1256  // verify sparse tag in all expected lists
1257  CHECK( contains_tag( sparse, sparse_ent_tags ) );
1258  CHECK( contains_tag( sparse, sparse_dense_ent_tags ) );
1259  CHECK( contains_tag( sparse, sparse_bit_ent_tags ) );
1260  CHECK( contains_tag( sparse, all_tag_ent_tags ) );
1261 
1262  // verify sparse tag not in any other lists
1263  CHECK( !contains_tag( sparse, dense_ent_tags ) );
1264  CHECK( !contains_tag( sparse, bit_ent_tags ) );
1265  CHECK( !contains_tag( sparse, dense_bit_ent_tags ) );
1266  CHECK( !contains_tag( sparse, no_tag_ent_tags ) );
1267 
1268  // verify dense tag in all expected lists
1269  CHECK( contains_tag( dense, dense_ent_tags ) );
1270  CHECK( contains_tag( dense, sparse_dense_ent_tags ) );
1271  CHECK( contains_tag( dense, dense_bit_ent_tags ) );
1272  CHECK( contains_tag( dense, all_tag_ent_tags ) );
1273 
1274  // verify bit tag in all expected lists
1275  CHECK( contains_tag( bit, bit_ent_tags ) );
1276  CHECK( contains_tag( bit, sparse_bit_ent_tags ) );
1277  CHECK( contains_tag( bit, dense_bit_ent_tags ) );
1278  CHECK( contains_tag( bit, all_tag_ent_tags ) );
1279 }

References CHECK, CHECK_ERR, contains_tag(), entities, ErrorCode, moab::Core::get_entities_by_handle(), mb, MB_TAG_BIT, MB_TAG_DENSE, MB_TAG_SPARSE, MB_TYPE_BIT, MB_TYPE_INTEGER, setup_mesh(), moab::Core::tag_get_tags_on_entity(), moab::Core::tag_set_data(), and test_create_tag().

Referenced by main().

◆ test_get_ents_with_default_value()

void test_get_ents_with_default_value ( )

Definition at line 1751 of file TagTest.cpp.

1752 {
1753  Core moab;
1754  Interface& mb = moab;
1755  ErrorCode rval;
1756  Range result;
1757 
1758  // create a bunch of vertices
1759  std::vector< double > coords( 90, 0.0 );
1760  Range verts;
1761  rval = mb.create_vertices( &coords[0], coords.size() / 3, verts );CHECK_ERR( rval );
1762  CHECK_EQUAL( coords.size() / 3, (size_t)verts.size() );
1763  // create one edge, which we should never get back from
1764  // our queries with type == MBVERTEX
1765  EntityHandle edge, ends[] = { verts.front(), verts.back() };
1766  rval = mb.create_element( MBEDGE, ends, 2, edge );CHECK_ERR( rval );
1767 
1768  // split vertices into four groups
1769  Range sets[4];
1770  size_t s = 0;
1771  for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
1772  {
1773  sets[s].insert( *i );
1774  s = ( s + 1 ) % 4;
1775  }
1776 
1777  // create a sparse tag and set some verts to non-default value
1778  int default_sparse = 5;
1779  Tag tag_sparse = test_create_tag( mb, "int", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, &default_sparse );
1780  std::vector< int > sparse_vals( sets[0].size(), -1 );
1781  rval = mb.tag_set_data( tag_sparse, sets[0], &sparse_vals[0] );CHECK_ERR( rval );
1782 
1783  // get all entities with default value for sparse tag
1784  result.clear();
1785  const void* ptrs[] = { &default_sparse };
1786  rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag_sparse, ptrs, 1, result );CHECK_ERR( rval );
1787  CHECK_EQUAL( subtract( verts, sets[0] ), result );
1788 
1789  // create a dense tag and set some verts to non-default value
1790  double default_dense = -1.0;
1791  Tag tag_dense = test_create_tag( mb, "double", 1, MB_TAG_DENSE, MB_TYPE_DOUBLE, &default_dense );
1792  std::vector< double > dense_vals( sets[1].size(), 3.14159 );
1793  rval = mb.tag_set_data( tag_dense, sets[1], &dense_vals[0] );CHECK_ERR( rval );
1794 
1795  // get all entities with default value for dense tag
1796  result.clear();
1797  ptrs[0] = &default_dense;
1798  rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag_dense, ptrs, 1, result );CHECK_ERR( rval );
1799  CHECK_EQUAL( subtract( verts, sets[1] ), result );
1800 
1801  // create a variable-length tag and set some verts to non-default value
1802  // SKIP THIS: NO API FOR QUERYING ENTITIES WITH VARIABLE-LENGTH VALUE
1803  // int default_vlen[] = { 1, 2, 3 };
1804  // Tag tag_vlen = test_create_var_len_tag( mb, "vlen", MB_TAG_SPARSE, MB_TYPE_INTEGER,
1805  // default_vlen, sizeof(default_vlen) ); int other_vlen[] = { 4, 5, 6, 7 }; std::vector<const
1806  // void*> vlen_ptrs( sets[2].size(), other_vlen ); std::vector<int> vlen_sizes( sets[2].size)(),
1807  // sizeof(other_vlen) ); rval = mb.tag_set_data( tag_vlen, sets[2], &vlen_ptrs[0],
1808  // &vlen_sizes[0]
1809  // ); CHECK_ERR(rval);
1810 
1811  // check that INTERSECT option works as expected
1812  result.clear();
1813  result.insert( sets[1].front() );
1814  ptrs[0] = &default_sparse;
1815  rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag_sparse, ptrs, 1, result, Interface::INTERSECT );CHECK_ERR( rval );
1816  CHECK_EQUAL( (size_t)1, result.size() );
1817  CHECK_EQUAL( sets[1].front(), result.front() );
1818 
1819  // check that UNITE option works as expected
1820  result.clear();
1821  result.insert( edge );
1822  ptrs[0] = &default_sparse;
1823  rval = mb.get_entities_by_type_and_tag( 0, MBVERTEX, &tag_sparse, ptrs, 1, result, Interface::UNION );CHECK_ERR( rval );
1824  CHECK_EQUAL( edge, result.back() );
1825 }

References moab::Range::back(), moab::Range::begin(), CHECK_EQUAL, CHECK_ERR, moab::Range::clear(), moab::Core::create_element(), moab::Core::create_vertices(), moab::Range::end(), ErrorCode, moab::Range::front(), moab::Core::get_entities_by_type_and_tag(), moab::Range::insert(), moab::Interface::INTERSECT, mb, MB_TAG_DENSE, MB_TAG_SPARSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, MBEDGE, MBVERTEX, size, moab::Range::size(), moab::subtract(), moab::Core::tag_set_data(), test_create_tag(), and moab::Interface::UNION.

Referenced by main().

◆ test_get_pointers_dense()

void test_get_pointers_dense ( )

Definition at line 690 of file TagTest.cpp.

691 {
692  const unsigned char data[] = "a few aribtrary bytes entered as a string";
693  const int num_val = sizeof( data ) / sizeof( data[0] );
694 
695  test_get_set( "dense_byte_ptr", 2, MB_TAG_DENSE, MB_TYPE_OPAQUE, data, num_val / 2, 0, NORMAL, true );
696 
697  const unsigned char defaultval[] = "XY";
698  test_get_set( "dense_byte_ptr_def", 2, MB_TAG_DENSE, MB_TYPE_OPAQUE, data, num_val / 2, defaultval, NORMAL, true );
699 }

References MB_TAG_DENSE, MB_TYPE_OPAQUE, NORMAL, and test_get_set().

Referenced by main().

◆ test_get_pointers_sparse()

void test_get_pointers_sparse ( )

Definition at line 679 of file TagTest.cpp.

680 {
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] );
683 
684  test_get_set( "sparse_dbl_ptr", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, data, num_val / 2, 0, NORMAL, true );
685 
686  const double defaultval[] = { -1, -2 };
687  test_get_set( "sparse_dbl_ptr_def", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, data, num_val / 2, defaultval, NORMAL, true );
688 }

References MB_TAG_SPARSE, MB_TYPE_DOUBLE, NORMAL, and test_get_set().

Referenced by main().

◆ test_get_set()

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.

370 {
371  std::vector< unsigned char > data;
372 
373  // create mesh and tag
374  Core moab;
375  Interface& mb = moab;
376  setup_mesh( mb );
377  Tag tag = test_create_tag( mb, name, vals_per_ent, storage, type, default_value );
378 
379  // get some handles to work with
380  Range entities;
381  ErrorCode rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
382  CHECK( !entities.empty() );
383 
384  int bytes = 0;
385  switch( type )
386  {
387  case MB_TYPE_INTEGER:
388  bytes = vals_per_ent * sizeof( int );
389  break;
390  case MB_TYPE_DOUBLE:
391  bytes = vals_per_ent * sizeof( double );
392  break;
393  case MB_TYPE_HANDLE:
394  bytes = vals_per_ent * sizeof( EntityHandle );
395  break;
396  case MB_TYPE_BIT:
397  bytes = 1;
398  break;
399  case MB_TYPE_OPAQUE:
400  bytes = vals_per_ent;
401  break;
402  }
403 
404  // split handles into four groups
405  // a) a single handle
406  // b) some non-consecutive handles in an array
407  // c) some handles in an Range
408  // d) remaining handles (remaining in 'entities');
409  EntityHandle one_handle;
410  Range::iterator it = entities.begin() += entities.size() / 2;
411  one_handle = *it;
412  entities.erase( it );
413 
414  Range handle_range;
415  std::vector< EntityHandle > handle_list;
416  for( Range::const_pair_iterator i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
417  {
418  if( i->first == i->second || i->second - i->first == 1 )
419  {
420  EntityHandle h1 = i->first, h2 = i->second;
421  ++i;
422  handle_range.insert( h1, h2 );
423  }
424  else
425  {
426  EntityHandle mid = (EntityHandle)( i->first + ( i->second - i->first + 1 ) / 2 );
427  handle_list.push_back( mid );
428  handle_range.insert( mid + 1, i->second );
429  }
430  }
431  entities = subtract( entities, handle_range );
432  for( unsigned i = 0; i < handle_list.size(); ++i )
433  entities.erase( handle_list[i] );
434 
435  // try getting/setting single handle value
436 
437  std::vector< const void* > list( 1 );
438  if( set_mode == NORMAL )
439  {
440  rval = mb.tag_set_data( tag, &one_handle, 1, some_values );
441  }
442  else if( set_mode == POINTER )
443  {
444  list[0] = some_values;
445  rval = mb.tag_set_by_ptr( tag, &one_handle, 1, &list[0] );
446  }
447  else
448  { // set_mode == ONE_VALUE
449  rval = mb.tag_clear_data( tag, &one_handle, 1, some_values );
450  }
451  CHECK_ERR( rval );
452  data.resize( bytes );
453  if( get_by_pointer )
454  {
455  // test that correct size is returned
456  int rsize;
457  rval = mb.tag_get_by_ptr( tag, &one_handle, 1, &list[0], &rsize );CHECK_ERR( rval );
458  CHECK_EQUAL( vals_per_ent, rsize );
459  // try again with NULL size pointer
460  list[0] = 0;
461  rval = mb.tag_get_by_ptr( tag, &one_handle, 1, &list[0] );CHECK_ERR( rval );
462  CHECK( !memcmp( some_values, list[0], bytes ) );
463  }
464  else
465  {
466  rval = mb.tag_get_data( tag, &one_handle, 1, &data[0] );CHECK_ERR( rval );
467  CHECK( !memcmp( some_values, &data[0], bytes ) );
468  }
469 
470  // try getting/setting for arrays of handles
471 
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 )
475  {
476  const int n = std::min( (int)handle_list.size() - i, step );
477  list.resize( n );
478  if( set_mode == NORMAL )
479  {
480  rval = mb.tag_set_data( tag, &handle_list[i], n, some_values );
481  }
482  else if( set_mode == POINTER )
483  {
484  concat_to_list( some_values, list, bytes );
485  rval = mb.tag_set_by_ptr( tag, &handle_list[i], n, &list[0] );
486  }
487  else
488  {
489  rval = mb.tag_clear_data( tag, &handle_list[i], n, some_values );
490  }
491  CHECK_ERR( rval );
492 
493  if( get_by_pointer )
494  {
495  // check that valid sizes are returned if requested
496  std::vector< int > rsizes( n, 0 );
497  rval = mb.tag_get_by_ptr( tag, &handle_list[i], n, &list[0], &rsizes[0] );CHECK_ERR( rval );
498  for( int j = 0; j < n; ++j )
499  CHECK_EQUAL( vals_per_ent, rsizes[j] );
500  // query a second time to verify that it works w/ NULL size array
501  list.clear();
502  list.resize( n, 0 );
503  rval = mb.tag_get_by_ptr( tag, &handle_list[i], n, &list[0] );
504  }
505  else
506  {
507  rval = mb.tag_get_data( tag, &handle_list[i], n, &data[0] );
508  concat_to_list( &data[0], list, bytes );
509  }
510  CHECK_ERR( rval );
511 
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 ) );
515  }
516 
517  // try getting/setting for Range of handles
518 
519  // set data for range
520  if( set_mode == NORMAL )
521  {
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 ) );
525  rval = mb.tag_set_data( tag, handle_range, &input_data[0] );
526  }
527  else if( set_mode == POINTER )
528  {
529  list.resize( num_values );
530  concat_to_list( some_values, list, bytes );
531  while( list.size() < handle_range.size() )
532  {
533  size_t s = list.size();
534  list.resize( 2 * s );
535  std::copy( list.begin(), list.begin() + s, list.begin() + s );
536  }
537  rval = mb.tag_set_by_ptr( tag, handle_range, &list[0] );
538  }
539  else
540  {
541  rval = mb.tag_clear_data( tag, handle_range, some_values );
542  }
543  CHECK_ERR( rval );
544 
545  // get data for range
546  list.clear();
547  list.resize( handle_range.size(), 0 );
548  if( get_by_pointer )
549  {
550  // check that valid sizes are returned if requested
551  std::vector< int > rsizes( handle_range.size(), 0 );
552  rval = mb.tag_get_by_ptr( tag, handle_range, &list[0], &rsizes[0] );CHECK_ERR( rval );
553  for( size_t j = 0; j < handle_range.size(); ++j )
554  CHECK_EQUAL( vals_per_ent, rsizes[j] );
555  // query w/ NULL size array to make sure that works also
556  list.clear();
557  list.resize( handle_range.size(), 0 );
558  rval = mb.tag_get_by_ptr( tag, handle_range, &list[0] );
559  }
560  else
561  {
562  data.resize( handle_range.size() * bytes );
563  concat_to_list( &data[0], list, bytes );
564  rval = mb.tag_get_data( tag, handle_range, &data[0] );
565  }
566  CHECK_ERR( rval );
567 
568  // compare values
569  const bool dstep = ( set_mode != ONE_VALUE );
570  for( size_t i = 0; i < list.size(); ++i )
571  {
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 ) );
575  }
576 
577  // try getting unset values
578 
579  list.resize( entities.size() );
580  if( get_by_pointer )
581  {
582  rval = mb.tag_get_by_ptr( tag, entities, &list[0] );
583  }
584  else
585  {
586  data.clear(), data.resize( entities.size() * bytes, '\001' );
587  concat_to_list( &data[0], list, bytes );
588  rval = mb.tag_get_data( tag, entities, &data[0] );
589  }
590  // if there was a default value, we should have gotten it for all unset entities
591  if( default_value )
592  {
593  CHECK_ERR( rval );
594  for( unsigned i = 0; i < entities.size(); ++i )
595  CHECK( !memcmp( default_value, list[i], bytes ) );
596  }
597  // otherwise we should get MB_TAG_NOT_FOUND, *unless* the tag
598  // is dense, in which case we /might/ get all zero bytes instead.
599  else if( MB_TAG_NOT_FOUND != rval )
600  {
601  CHECK_EQUAL( MB_TAG_DENSE, storage );
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 ) );
605  }
606 
607  // Check that handles for other entities didn't change.
608 
609  // Ignore get_by_pointer/set_by_pointer flags from here on.
610  // We've established (hopefully) that both methods work in
611  // the above code. Now we just want to verify correct values,
612  // regardless of the API used to get them.
613 
614  // one handle
615  data.resize( bytes );
616  rval = mb.tag_get_data( tag, &one_handle, 1, &data[0] );CHECK_ERR( rval );
617  CHECK( !memcmp( some_values, &data[0], bytes ) );
618 
619  // array values
620  data.resize( step * bytes );
621  for( int i = 0; i < (int)handle_list.size(); i += step )
622  {
623  const int n = std::min( (int)handle_list.size() - i, step );
624  rval = mb.tag_get_data( tag, &handle_list[i], n, &data[0] );CHECK_ERR( rval );
625  CHECK( !memcmp( some_values, &data[0], step * bytes ) );
626  rval = mb.tag_set_data( tag, &handle_list[i], n, some_values );CHECK_ERR( rval );
627  }
628 
629  // range values
630  list.clear();
631  list.resize( handle_range.size(), 0 );
632  rval = mb.tag_get_by_ptr( tag, handle_range, &list[0] );CHECK_ERR( rval );
633  for( size_t i = 0; i < handle_range.size(); ++i )
634  {
635  const void* ptr = reinterpret_cast< const char* >( some_values ) + ( i % num_values ) * bytes;
636  CHECK( !memcmp( ptr, list[i], bytes ) );
637  }
638 }

References CHECK, CHECK_EQUAL, CHECK_ERR, concat_to_list(), entities, ErrorCode, moab::Core::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::Core::tag_clear_data(), moab::Core::tag_get_by_ptr(), moab::Core::tag_get_data(), moab::Core::tag_set_by_ptr(), moab::Core::tag_set_data(), and test_create_tag().

Referenced by test_clear_dense(), test_clear_sparse(), test_get_pointers_dense(), test_get_pointers_sparse(), test_get_set_dense_double(), test_get_set_dense_int(), test_get_set_sparse_int(), test_set_pointers_dense(), and test_set_pointers_sparse().

◆ test_get_set_bit()

void test_get_set_bit ( )

Definition at line 754 of file TagTest.cpp.

755 {
756  // create mesh and tag
757  Core moab;
758  Interface& mb = moab;
759  setup_mesh( mb );
760  Tag tag = test_create_tag( mb, "bit_val", 2, MB_TAG_BIT, MB_TYPE_BIT, 0 );
761 
762  // get some handles to work with
763  Range entities;
764  ErrorCode rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
765  CHECK( !entities.empty() );
766 
767  // set bits on every entity
768  unsigned counter = 0;
769  for( Range::iterator i = entities.begin(); i != entities.end(); ++i )
770  {
771  srand( counter++ );
772  unsigned char bits = (unsigned char)( rand() & 3 );
773  rval = mb.tag_set_data( tag, &*i, 1, &bits );CHECK_ERR( rval );
774  unsigned char bits_out = 0;
775  rval = mb.tag_get_data( tag, &*i, 1, &bits_out );CHECK_ERR( rval );
776  CHECK_EQUAL( bits, bits_out );
777  }
778 
779  // test default value
780  unsigned char defval = '\003';
781  unsigned char zero = '\0';
782  Tag tag2 = test_create_tag( mb, "bit_val2", 3, MB_TAG_BIT, MB_TYPE_BIT, &defval );
783  CHECK( entities.size() >= 3 );
784  Range::iterator j = entities.begin();
785  EntityHandle h1 = *j;
786  ++j;
787  EntityHandle h2 = *j;
788  ++j;
789  EntityHandle h3 = *j;
790  ++j;
791  rval = mb.tag_set_data( tag2, &h1, 1, &zero );CHECK_ERR( rval );
792  rval = mb.tag_set_data( tag2, &h3, 1, &zero );CHECK_ERR( rval );
793  unsigned char byte;
794  rval = mb.tag_get_data( tag2, &h2, 1, &byte );CHECK_ERR( rval );
795  CHECK_EQUAL( defval, byte );
796  rval = mb.tag_get_data( tag2, &h1, 1, &byte );CHECK_ERR( rval );
797  CHECK_EQUAL( zero, byte );
798  rval = mb.tag_get_data( tag2, &h3, 1, &byte );CHECK_ERR( rval );
799  CHECK_EQUAL( zero, byte );
800 
801  // test default value for uninitialized data (tag not set for any entity)
802  defval = '\002';
803  Tag tag3 = test_create_tag( mb, "bit_val3", 2, MB_TAG_BIT, MB_TYPE_BIT, &defval );
804  rval = mb.tag_get_data( tag3, &h2, 1, &byte );CHECK_ERR( rval );
805  CHECK_EQUAL( defval, byte );
806 }

References CHECK, CHECK_EQUAL, CHECK_ERR, entities, ErrorCode, moab::Core::get_entities_by_handle(), h1, mb, MB_TAG_BIT, MB_TYPE_BIT, setup_mesh(), moab::Core::tag_get_data(), moab::Core::tag_set_data(), and test_create_tag().

Referenced by main().

◆ test_get_set_dense_double()

void test_get_set_dense_double ( )

Definition at line 664 of file TagTest.cpp.

665 {
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] );
672 
673  test_get_set( "dense_dbl", 1, MB_TAG_DENSE, MB_TYPE_DOUBLE, data, num_val, 0 );
674 
675  const double defaultval[] = { 0.11, 0.22 };
676  test_get_set( "dense_dbl_def", 2, MB_TAG_DENSE, MB_TYPE_DOUBLE, data, num_val / 2, defaultval );
677 }

References MB_TAG_DENSE, MB_TYPE_DOUBLE, and test_get_set().

Referenced by main().

◆ test_get_set_dense_int()

void test_get_set_dense_int ( )

Definition at line 652 of file TagTest.cpp.

653 {
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] );
657 
658  test_get_set( "dense_int", 1, MB_TAG_DENSE, MB_TYPE_INTEGER, data, num_val, 0 );
659 
660  const int defaultval[] = { 5, 8, 1974 };
661  test_get_set( "dense_int_def", 3, MB_TAG_DENSE, MB_TYPE_INTEGER, data, num_val / 3, defaultval );
662 }

References MB_TAG_DENSE, MB_TYPE_INTEGER, and test_get_set().

Referenced by main().

◆ test_get_set_sparse_int()

void test_get_set_sparse_int ( )

Definition at line 640 of file TagTest.cpp.

641 {
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] );
645 
646  test_get_set( "sparse_int", 2, MB_TAG_SPARSE, MB_TYPE_INTEGER, data, num_val / 2, 0 );
647 
648  const int defaultval = 19740508;
649  test_get_set( "sparse_int_def", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, data, num_val, &defaultval );
650 }

References MB_TAG_SPARSE, MB_TYPE_INTEGER, and test_get_set().

Referenced by main().

◆ test_get_set_variable_length()

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.

1456 {
1457  std::vector< const void* > data;
1458  std::vector< int > data_lens;
1459 
1460  // create mesh and tag
1461  Core moab;
1462  Interface& mb = moab;
1463  setup_mesh( mb );
1464  Tag tag = test_create_var_len_tag( mb, name, storage, type, default_value, default_value_length );
1465 
1466  // get some handles to work with
1467  Range entities;
1468  ErrorCode rval = mb.get_entities_by_handle( 0, entities );CHECK_ERR( rval );
1469  CHECK( !entities.empty() );
1470 
1471  // split handles into four groups
1472  // a) a single handle
1473  // b) some non-consecutive handles in an array
1474  // c) some handles in an Range
1475  // d) remaining handles (remaining in 'entities');
1476  EntityHandle one_handle;
1477  Range::iterator it = entities.begin() += entities.size() / 2;
1478  one_handle = *it;
1479  entities.erase( it );
1480 
1481  Range handle_range;
1482  std::vector< EntityHandle > handle_list;
1483  for( Range::const_pair_iterator i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
1484  {
1485  if( i->first == i->second || i->second - i->first == 1 )
1486  {
1487  EntityHandle h1 = i->first, h2 = i->second;
1488  ++i;
1489  handle_range.insert( h1, h2 );
1490  }
1491  else
1492  {
1493  EntityHandle mid = (EntityHandle)( i->first + ( i->second - i->first + 1 ) / 2 );
1494  handle_list.push_back( mid );
1495  handle_range.insert( mid + 1, i->second );
1496  }
1497  }
1498  entities = subtract( entities, handle_range );
1499  for( unsigned i = 0; i < handle_list.size(); ++i )
1500  entities.erase( handle_list[i] );
1501 
1502  // try getting/setting single handle value
1503  if( num_values == 1 )
1504  rval = mb.tag_clear_data( tag, &one_handle, 1, values[0], lengths[0] );
1505  else
1506  rval = mb.tag_set_by_ptr( tag, &one_handle, 1, values, lengths );CHECK_ERR( rval );
1507  const void* data_ptr;
1508  int data_len;
1509  rval = mb.tag_get_by_ptr( tag, &one_handle, 1, &data_ptr, &data_len );CHECK_ERR( rval );
1510  CHECK_EQUAL( lengths[0], data_len );
1511  CHECK( !memcmp( values[0], data_ptr, data_len ) );
1512 
1513  int typesize = 0;
1514  switch( type )
1515  {
1516  case MB_TYPE_INTEGER:
1517  typesize = sizeof( int );
1518  break;
1519  case MB_TYPE_DOUBLE:
1520  typesize = sizeof( double );
1521  break;
1522  case MB_TYPE_HANDLE:
1523  typesize = sizeof( EntityHandle );
1524  break;
1525  case MB_TYPE_BIT:
1526  typesize = 1;
1527  break;
1528  case MB_TYPE_OPAQUE:
1529  typesize = 1;
1530  break;
1531  }
1532 
1533  // try getting/setting for arrays of handles
1534 
1535  int count, step;
1536  if( num_values == 1 )
1537  {
1538  count = handle_list.size();
1539  step = 0;
1540  rval = mb.tag_clear_data( tag, &handle_list[0], count, values[0], lengths[0] );
1541  }
1542  else
1543  {
1544  count = std::min( (int)handle_list.size(), num_values );
1545  step = 1;
1546  rval = mb.tag_set_by_ptr( tag, &handle_list[0], count, values, lengths );
1547  }
1548  CHECK_ERR( rval );
1549  data.clear();
1550  data.resize( count, 0 );
1551  data_lens.clear();
1552  data_lens.resize( count, 0 );
1553  rval = mb.tag_get_by_ptr( tag, &handle_list[0], count, &data[0], &data_lens[0] );CHECK_ERR( rval );
1554  for( int i = 0; i < count; ++i )
1555  {
1556  CHECK_EQUAL( lengths[i * step], data_lens[i] );
1557  CHECK( NULL != data[i] );
1558  CHECK( !memcmp( values[i], data[i * step], typesize * lengths[i * step] ) );
1559  }
1560 
1561  // try getting/setting for Range of handles
1562 
1563  if( num_values > 1 )
1564  {
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() )
1570  {
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 );
1576  }
1577  rval = mb.tag_set_by_ptr( tag, handle_range, &data[0], &data_lens[0] );
1578  }
1579  else
1580  {
1581  rval = mb.tag_clear_data( tag, handle_range, values[0], lengths[0] );
1582  }
1583  CHECK_ERR( rval );
1584 
1585  data.clear();
1586  data.resize( handle_range.size(), 0 );
1587  data_lens.clear();
1588  data_lens.resize( handle_range.size(), 0 );
1589  rval = mb.tag_get_by_ptr( tag, handle_range, &data[0], &data_lens[0] );CHECK_ERR( rval );
1590 
1591  for( size_t i = 0; i < data.size(); ++i )
1592  {
1593  const void* expect = values[( i * step ) % num_values];
1594  int expect_len = lengths[( i * step ) % num_values];
1595  CHECK_EQUAL( expect_len, data_lens[i] );
1596  CHECK( NULL != data[i] );
1597  CHECK( !memcmp( expect, data[i], expect_len * typesize ) );
1598  }
1599 
1600  // try getting unset values
1601 
1602  data.resize( entities.size() );
1603  data_lens.resize( entities.size() );
1604  rval = mb.tag_get_by_ptr( tag, entities, &data[0], &data_lens[0] );
1605  // if there was a default value, we should have gotten it for all unset entities
1606  if( default_value )
1607  {
1608  CHECK_ERR( rval );
1609  for( unsigned i = 0; i < entities.size(); ++i )
1610  {
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 ) );
1614  }
1615  }
1616  // otherwise we should get MB_TAG_NOT_FOUND
1617  else
1618  {
1619  CHECK_EQUAL( MB_TAG_NOT_FOUND, rval );
1620  }
1621 
1622  // Check that handles for other entities didn't change.
1623 
1624  // one handle
1625  rval = mb.tag_get_by_ptr( tag, &one_handle, 1, &data_ptr, &data_len );CHECK_ERR( rval );
1626  CHECK_EQUAL( lengths[0], data_len );
1627  CHECK( !memcmp( values[0], data_ptr, typesize * data_len ) );
1628 
1629  // array values
1630  count = std::min( (int)handle_list.size(), num_values );
1631  data.clear();
1632  data.resize( count, 0 );
1633  data_lens.clear();
1634  data_lens.resize( count, 0 );
1635  rval = mb.tag_get_by_ptr( tag, &handle_list[0], count, &data[0], &data_lens[0] );CHECK_ERR( rval );
1636  for( int i = 0; i < count; ++i )
1637  {
1638  CHECK_EQUAL( lengths[i], data_lens[i] );
1639  CHECK( NULL != data[i] );
1640  CHECK( !memcmp( values[i], data[i], typesize * lengths[i] ) );
1641  }
1642 
1643  // range values
1644  data.clear();
1645  data.resize( handle_range.size(), 0 );
1646  data_lens.clear();
1647  data_lens.resize( handle_range.size(), 0 );
1648  rval = mb.tag_get_by_ptr( tag, handle_range, &data[0], &data_lens[0] );CHECK_ERR( rval );
1649 
1650  for( size_t i = 0; i < data.size(); ++i )
1651  {
1652  const void* expect = values[i % num_values];
1653  int expect_len = lengths[i % num_values];
1654  CHECK_EQUAL( expect_len, data_lens[i] );
1655  CHECK( NULL != data[i] );
1656  CHECK( !memcmp( expect, data[i], typesize * expect_len ) );
1657  }
1658 }

References CHECK, CHECK_EQUAL, CHECK_ERR, entities, ErrorCode, moab::Core::get_entities_by_handle(), h1, moab::Range::insert(), mb, 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::Core::tag_clear_data(), moab::Core::tag_get_by_ptr(), moab::Core::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().

◆ test_get_set_variable_length_dense()

void test_get_set_variable_length_dense ( )

Definition at line 1676 of file TagTest.cpp.

1677 {
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 };
1681  test_get_set_variable_length( "vnodef", MB_TAG_DENSE, MB_TYPE_DOUBLE, dvals, dlens, 5, 0, 0 );
1682 
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 };
1685  const void* ivals[9] = { ints, ints + 1, ints + 3, ints + 12, ints + 17,
1686  ints + 21, ints + 28, ints + 29, ints + 31 };
1687  const int ilens[9] = { 1, 2, 9, 5, 4, 7, 1, 2, 1 };
1688  const int defvals[] = { 42, 5, 8, 74 };
1689  test_get_set_variable_length( "vdef", MB_TAG_DENSE, MB_TYPE_INTEGER, ivals, ilens, 9, defvals, 4 );
1690 }

References ints, MB_TAG_DENSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, and test_get_set_variable_length().

Referenced by main().

◆ test_get_set_variable_length_mesh()

void test_get_set_variable_length_mesh ( )

Definition at line 1692 of file TagTest.cpp.

1693 {
1694  Core moab;
1695  Interface& mb = moab;
1696  ErrorCode rval;
1697 
1698  Tag tag = test_create_var_len_tag( mb, "vmesh", MB_TAG_MESH, MB_TYPE_INTEGER, 0, 0 );
1699  int values1[] = { 6 };
1700  int values5[] = { 1, 2, 3, 4, 5 };
1701 
1702  int one = 1;
1703  const void* data[1];
1704  data[0] = values1;
1705  const EntityHandle mesh = 0;
1706  rval = mb.tag_set_by_ptr( tag, &mesh, 1, data, &one );CHECK_ERR( rval );
1707 
1708  int len;
1709  rval = mb.tag_get_by_ptr( tag, &mesh, 1, data, &len );CHECK_ERR( rval );
1710  CHECK_EQUAL( 1, len );
1711  CHECK_EQUAL( values1[0], *reinterpret_cast< const int* >( data[0] ) );
1712 
1713  int five = 5;
1714  data[0] = values5;
1715  rval = mb.tag_set_by_ptr( tag, &mesh, 1, data, &five );CHECK_ERR( rval );
1716 
1717  rval = mb.tag_get_by_ptr( tag, &mesh, 1, data, &len );CHECK_ERR( rval );
1718  CHECK_EQUAL( 5, len );
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] );
1724 }

References CHECK_EQUAL, CHECK_ERR, ErrorCode, mb, MB_TAG_MESH, MB_TYPE_INTEGER, mesh, moab::Core::tag_get_by_ptr(), moab::Core::tag_set_by_ptr(), and test_create_var_len_tag().

Referenced by main().

◆ test_get_set_variable_length_sparse()

void test_get_set_variable_length_sparse ( )

Definition at line 1660 of file TagTest.cpp.

1661 {
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 };
1665  test_get_set_variable_length( "vnodef", MB_TAG_SPARSE, MB_TYPE_DOUBLE, dvals, dlens, 5, 0, 0 );
1666 
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 };
1669  const void* ivals[9] = { ints, ints + 1, ints + 3, ints + 12, ints + 17,
1670  ints + 21, ints + 28, ints + 29, ints + 31 };
1671  const int ilens[9] = { 1, 2, 9, 5, 4, 7, 1, 2, 1 };
1672  const int defvals[] = { 42, 5, 8, 74 };
1673  test_get_set_variable_length( "vdef", MB_TAG_SPARSE, MB_TYPE_INTEGER, ivals, ilens, 9, defvals, 4 );
1674 }

References ints, MB_TAG_SPARSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, and test_get_set_variable_length().

Referenced by main().

◆ test_mesh_value() [1/2]

void test_mesh_value ( )

Definition at line 1084 of file TagTest.cpp.

1085 {
1086  Core moab;
1087 
1088  double dval = -0.5;
1089  test_mesh_value( moab, "mvd", 1, MB_TAG_DENSE, MB_TYPE_DOUBLE, &dval );
1090 
1091  int sval = 42;
1092  test_mesh_value( moab, "mvs", 1, MB_TAG_SPARSE, MB_TYPE_INTEGER, &sval );
1093 
1094  EntityHandle mval = 0;
1095  test_mesh_value( moab, "mvm", 1, MB_TAG_MESH, MB_TYPE_HANDLE, &mval );
1096 
1097  unsigned char bits = '\002';
1098  test_mesh_value( moab, "mvb", 2, MB_TAG_BIT, MB_TYPE_BIT, &bits );
1099 }

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().

◆ test_mesh_value() [2/2]

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.

1055 {
1056  // create tag
1057  Tag tag = test_create_tag( mb, tag_name, tag_size, tag_storage, tag_type, 0 );
1058 
1059  unsigned memcmp_size = tag_size;
1060  if( tag_storage == MB_TAG_BIT || tag_type == MB_TYPE_BIT )
1061  memcmp_size = 1;
1062  else if( tag_type == MB_TYPE_DOUBLE )
1063  memcmp_size = sizeof( double );
1064  else if( tag_type == MB_TYPE_INTEGER )
1065  memcmp_size = sizeof( int );
1066  if( tag_type == MB_TYPE_HANDLE ) memcmp_size = sizeof( EntityHandle );
1067 
1068  const EntityHandle mesh = 0;
1069  ErrorCode rval = mb.tag_set_data( tag, &mesh, 1, value );CHECK_ERR( rval );
1070  std::vector< unsigned char > bytes( memcmp_size, 0 );
1071  rval = mb.tag_get_data( tag, &mesh, 1, &bytes[0] );CHECK_ERR( rval );
1072  CHECK( !memcmp( value, &bytes[0], memcmp_size ) );
1073 
1074  // test again, this time for default value
1075  std::string name2( tag_name );
1076  name2 += "_DEF";
1077  Tag tag2 = test_create_tag( mb, name2.c_str(), tag_size, tag_storage, tag_type, value );
1078  bytes.clear();
1079  bytes.resize( memcmp_size, 0 );
1080  rval = mb.tag_get_data( tag2, &mesh, 1, &bytes[0] );CHECK_ERR( rval );
1081  CHECK( !memcmp( value, &bytes[0], memcmp_size ) );
1082 }

References CHECK, CHECK_ERR, ErrorCode, mb, MB_TAG_BIT, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, mesh, moab::Core::tag_get_data(), moab::Core::tag_set_data(), and test_create_tag().

◆ test_set_pointers_dense()

void test_set_pointers_dense ( )

Definition at line 713 of file TagTest.cpp.

714 {
715  const unsigned char data[] = "a few aribtrary bytes entered as a string";
716  const int num_val = sizeof( data ) / sizeof( data[0] );
717 
718  test_get_set( "dense_byte_ptr", 2, MB_TAG_DENSE, MB_TYPE_OPAQUE, data, num_val / 2, 0, POINTER, false );
719 
720  const unsigned char defaultval[] = "XY";
721  test_get_set( "dense_byte_ptr_def", 2, MB_TAG_DENSE, MB_TYPE_OPAQUE, data, num_val / 2, defaultval, POINTER,
722  false );
723 
724  const double dbldata[3] = { 1.0, 2.0, 3.0 };
725  const int dbl_num_val = sizeof( dbldata ) / sizeof( double );
726 
727  test_get_set( "dense_double_ptr", 3, MB_TAG_DENSE, MB_TYPE_DOUBLE, dbldata, dbl_num_val, 0, POINTER, false );
728 
729  const double dbldefaultval[3] = { 0.0, 0.0, 0.0 };
730  test_get_set( "dense_byte_ptr_def", 3, MB_TAG_DENSE, MB_TYPE_DOUBLE, dbldata, dbl_num_val, dbldefaultval, POINTER,
731  false );
732 }

References MB_TAG_DENSE, MB_TYPE_DOUBLE, MB_TYPE_OPAQUE, POINTER, and test_get_set().

Referenced by main().

◆ test_set_pointers_sparse()

void test_set_pointers_sparse ( )

Definition at line 701 of file TagTest.cpp.

702 {
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] );
705 
706  test_get_set( "sparse_dbl_ptr", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, data, num_val / 2, 0, POINTER, false );
707 
708  const double defaultval[] = { -1, -2 };
709  test_get_set( "sparse_dbl_ptr_def", 2, MB_TAG_SPARSE, MB_TYPE_DOUBLE, data, num_val / 2, defaultval, POINTER,
710  false );
711 }

References MB_TAG_SPARSE, MB_TYPE_DOUBLE, POINTER, and test_get_set().

Referenced by main().

◆ test_tag_iterate_common()

void test_tag_iterate_common ( TagType  storage,
bool  with_default 
)

Definition at line 2037 of file TagTest.cpp.

2038 {
2039  // create 1000 vertices
2040  const int NUM_VTX = 1000;
2041  Core moab;
2042  Interface& mb = moab;
2043  std::vector< double > coords( 3 * NUM_VTX );
2044  Range verts, dead;
2045  ErrorCode rval = mb.create_vertices( &coords[0], NUM_VTX, verts );CHECK_ERR( rval );
2046 
2047  // delete about 1% of vertices
2048  const int step = 100;
2049  int remaining = NUM_VTX;
2050  Range::iterator i = verts.begin();
2051  for( int j = 0; j < remaining; j += step )
2052  {
2053  rval = mb.delete_entities( &*i, 1 );CHECK_ERR( rval );
2054  dead.insert( *i );
2055  i = verts.erase( i );
2056  i += step - 1;
2057  }
2058 
2059  // Remove some additional values from the range
2060  // so that our handle blocks don't always align with
2061  // sequences
2062  verts.erase( verts.begin() + ( step - 5 ), verts.begin() + ( step + 5 ) );
2063 
2064  // Create an integer tag
2065  Tag tag;
2066  const int defval = 0;
2067  rval = mb.tag_get_handle( "TEST_TAG", 1, MB_TYPE_INTEGER, tag, storage | MB_TAG_CREAT, with_default ? &defval : 0 );CHECK_ERR( rval );
2068 
2069  // Set tag values
2070  std::vector< int > values( verts.size(), defval );
2071  if( !with_default )
2072  {
2073  for( size_t j = 0; j < values.size(); ++j )
2074  values[j] = j;
2075  rval = mb.tag_set_data( tag, verts, &values[0] );CHECK_ERR( rval );
2076  }
2077 
2078  // Check that we get back expected values
2079  i = verts.begin();
2080  void* ptr;
2081  int count, total = 0;
2082  while( i != verts.end() )
2083  {
2084  ptr = 0;
2085  rval = mb.tag_iterate( tag, i, verts.end(), count, ptr );CHECK_ERR( rval );
2086 
2087  assert( total + count <= (int)verts.size() );
2088  CHECK_ARRAYS_EQUAL( &values[total], count, reinterpret_cast< int* >( ptr ), count );
2089 
2090  if( i == verts.begin() && with_default && storage == MB_TAG_SPARSE ) ( (int*)ptr )[0] = 1.0;
2091 
2092  i += count;
2093  total += count;
2094  }
2095 
2096  // Check that we can set values
2097  i = verts.begin();
2098  while( i != verts.end() )
2099  {
2100  ptr = 0;
2101  rval = mb.tag_iterate( tag, i, verts.end(), count, ptr );CHECK_ERR( rval );
2102 
2103  Range::iterator end = i + count;
2104  int* arr = reinterpret_cast< int* >( ptr );
2105  while( end != i )
2106  {
2107  *arr = static_cast< int >( ( *i ) % NUM_VTX );
2108  ++i;
2109  ++arr;
2110  }
2111  }
2112 
2113  // Check that we got back the values that we set
2114  i = verts.begin();
2115  while( i != verts.end() )
2116  {
2117  ptr = 0;
2118  rval = mb.tag_iterate( tag, i, verts.end(), count, ptr );CHECK_ERR( rval );
2119 
2120  Range::iterator end = i + count;
2121  int* arr = reinterpret_cast< int* >( ptr );
2122  while( end != i )
2123  {
2124  CHECK_EQUAL( *arr, static_cast< int >( ( *i ) % NUM_VTX ) );
2125  ++i;
2126  ++arr;
2127  }
2128  }
2129 
2130  // Check that we cannot get tag values for invalid handles
2131  rval = mb.tag_iterate( tag, dead.begin(), dead.end(), count, ptr );
2132  CHECK( MB_ENTITY_NOT_FOUND == rval || MB_TAG_NOT_FOUND == rval );
2133 }

References moab::Range::begin(), CHECK, CHECK_ARRAYS_EQUAL, CHECK_EQUAL, CHECK_ERR, moab::Core::create_vertices(), moab::Core::delete_entities(), moab::Range::end(), moab::Range::erase(), ErrorCode, moab::Range::insert(), mb, MB_ENTITY_NOT_FOUND, MB_TAG_CREAT, MB_TAG_NOT_FOUND, MB_TAG_SPARSE, MB_TYPE_INTEGER, moab::Range::size(), moab::Core::tag_get_handle(), moab::Core::tag_iterate(), and moab::Core::tag_set_data().

Referenced by test_tag_iterate_dense(), test_tag_iterate_dense_default(), test_tag_iterate_sparse(), and test_tag_iterate_sparse_default().

◆ test_tag_iterate_dense()

void test_tag_iterate_dense ( )

Definition at line 2142 of file TagTest.cpp.

2143 {
2144  test_tag_iterate_common( MB_TAG_DENSE, false );
2145 }

References MB_TAG_DENSE, and test_tag_iterate_common().

Referenced by main().

◆ test_tag_iterate_dense_default()

void test_tag_iterate_dense_default ( )

Definition at line 2146 of file TagTest.cpp.

2147 {
2148  test_tag_iterate_common( MB_TAG_DENSE, true );
2149 }

References MB_TAG_DENSE, and test_tag_iterate_common().

Referenced by main().

◆ test_tag_iterate_invalid()

void test_tag_iterate_invalid ( )

Definition at line 2151 of file TagTest.cpp.

2152 {
2153  // create 1000 vertices
2154  const int NUM_VTX = 1000;
2155  Core moab;
2156  Interface& mb = moab;
2157  std::vector< double > coords( 3 * NUM_VTX );
2158  Range verts;
2159  ErrorCode rval = mb.create_vertices( &coords[0], NUM_VTX, verts );CHECK_ERR( rval );
2160 
2161  Tag tag;
2162  const int zero = 0;
2163  void* ptr;
2164  int count;
2165 
2166  // Check that we cannot iterate over bit tags
2167  // (this will never be possible because the storage for bit tags
2168  // is compressed and therefore cannot be directly accessed.)
2169  rval = mb.tag_get_handle( "bits", 1, MB_TYPE_BIT, tag, MB_TAG_EXCL, &zero );CHECK_ERR( rval );
2170  rval = mb.tag_iterate( tag, verts.begin(), verts.end(), count, ptr );
2171  CHECK_EQUAL( MB_TYPE_OUT_OF_RANGE, rval );
2172 
2173  // Check that we cannot iterate over variable-length tags
2174  // (this will never be possible because this API function cannot
2175  // pass back the length of the tag values)
2176  rval = mb.tag_get_handle( "vden", 1, MB_TYPE_INTEGER, tag, MB_TAG_VARLEN | MB_TAG_DENSE | MB_TAG_EXCL, &zero );CHECK_ERR( rval );
2177  rval = mb.tag_iterate( tag, verts.begin(), verts.end(), count, ptr );
2178  CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, rval );
2179 
2180  rval = mb.tag_get_handle( "vspr", 1, MB_TYPE_INTEGER, tag, MB_TAG_VARLEN | MB_TAG_SPARSE | MB_TAG_EXCL, &zero );CHECK_ERR( rval );
2181  rval = mb.tag_iterate( tag, verts.begin(), verts.end(), count, ptr );
2182  CHECK_EQUAL( MB_VARIABLE_DATA_LENGTH, rval );
2183 }

References moab::Range::begin(), CHECK_EQUAL, CHECK_ERR, moab::Core::create_vertices(), moab::Range::end(), ErrorCode, mb, 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::Core::tag_get_handle(), and moab::Core::tag_iterate().

Referenced by main().

◆ test_tag_iterate_sparse()

void test_tag_iterate_sparse ( )

Definition at line 2134 of file TagTest.cpp.

2135 {
2136  test_tag_iterate_common( MB_TAG_SPARSE, false );
2137 }

References MB_TAG_SPARSE, and test_tag_iterate_common().

Referenced by main().

◆ test_tag_iterate_sparse_default()

void test_tag_iterate_sparse_default ( )

Definition at line 2138 of file TagTest.cpp.

2139 {
2140  test_tag_iterate_common( MB_TAG_SPARSE, true );
2141 }

References MB_TAG_SPARSE, and test_tag_iterate_common().

Referenced by main().