testc_cbind.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "iMesh.h"
#include "iMesh_extensions.h"
#include "moab/Types.hpp"
using namespace moab;
extern enum iBase_ErrorType iBase_ERROR_MAP[MB_FAILURE + 1];


#define FALSE 0
#define TRUE 1

#define DEFAULT_TEST_FILE brick.vtk

#define STRINGIFY_(X) #X
#define STRINGIFY(X) STRINGIFY_(X)
#ifdef SRCDIR
#  define DEFAULT_INPUT_FILE STRINGIFY(SRCDIR/DEFAULT_TEST_FILE)
#else
#  define DEFAULT_INPUT_FILE STRINGIFY(DEFAULT_TEST_FILE)
#endif

static bool assert_pass;
#define ASSERT(COND) \
  assert_pass = true; \
  if (!(COND)) { \
    PRINT_ASSERT_FAILURE(#COND, __FILE__, __LINE__); \
    assert_pass = false; \
  }

void PRINT_ASSERT_FAILURE(const char* cond, const char* file, int line)
{
  printf("Condition: %s\n", cond );
  printf(" failed at %s line %d\n", file, line );
}

#define CHK(err) if (err != iBase_SUCCESS) \
  do {printf("%s:%d ITAPS error %d\n", __FILE__, __LINE__, err); return 0;} while (0)

static iBase_EntitySetHandle root_set;

void handle_error_code(const int result,
                       int *number_failed,
                       int * /*number_not_implemented*/,
                       int *number_successful)
{
  if (result) {
    printf("Success\n");
    (*number_successful)++;
  }
  else {
    printf("Failure\n");
    (*number_failed)++;
  }
}

int load_mesh_test(const char *filename, iMesh_Instance mesh)
{
    /* load a mesh */
  int result;
  iMesh_load(mesh, root_set, filename, NULL, &result, strlen(filename), 0);
  if (iBase_SUCCESS != result) {
    printf("ERROR : can not load a mesh from file %s\n", filename);
    return FALSE;
  }

  return TRUE;
}

#define TEST_ERROR_CODE( A, B ) \
  if (iBase_ERROR_MAP[(A)] != (B)) { \
    printf("ERROR: Invalid mapping for MOAB error code %s\n", #A); \
    printf("       Expected %d, actual is %d\n", (int)iBase_ERROR_MAP[(A)], (int)(B) ); \
    return FALSE; \
  }

int error_code_test(iMesh_Instance /*mesh*/) {
  TEST_ERROR_CODE( MB_SUCCESS,                  iBase_SUCCESS )
  TEST_ERROR_CODE( MB_TYPE_OUT_OF_RANGE,        iBase_INVALID_ENTITY_TYPE )
  TEST_ERROR_CODE( MB_MEMORY_ALLOCATION_FAILED, iBase_MEMORY_ALLOCATION_FAILED )
  TEST_ERROR_CODE( MB_ENTITY_NOT_FOUND,         iBase_INVALID_ENTITY_HANDLE )
  TEST_ERROR_CODE( MB_TAG_NOT_FOUND,            iBase_TAG_NOT_FOUND )
  TEST_ERROR_CODE( MB_FILE_DOES_NOT_EXIST,      iBase_FILE_NOT_FOUND )
  TEST_ERROR_CODE( MB_UNSUPPORTED_OPERATION,    iBase_NOT_SUPPORTED )
  TEST_ERROR_CODE( MB_UNHANDLED_OPTION,         iBase_INVALID_ARGUMENT )
  TEST_ERROR_CODE( MB_FAILURE,                  iBase_FAILURE )
  return TRUE;
}

int topology_dimension_test(iMesh_Instance mesh)
{
  iBase_EntityHandle *faces = NULL;
  int faces_alloc = 0, faces_size;
  int result, i;
  int *dimensions = NULL;
  int dimensions_alloc = 0, dimensions_size;

    /* first get 2D entities */
  iMesh_getEntities(mesh, root_set, iBase_FACE, 
                    iMesh_ALL_TOPOLOGIES, 
                    &faces, &faces_alloc, &faces_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get faces in entity_sets_test.\n");
    return FALSE;
  }

    /* get dimensions of faces */
  iMesh_getEntArrType(mesh, faces, faces_size, 
                      &dimensions, &dimensions_alloc, &dimensions_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get dimensions of faces in topology_test.\n");
    free(faces);
    return FALSE;
  }

  if (dimensions_size != faces_size) {
    printf("Didn't get the right number of types in topology_test.\n");
    free(faces);
    free(dimensions);
    return FALSE;
  }
    
    /* make sure all elements are 2D */
  for (i = 0; i < faces_size; i++) {
    if (dimensions[i] != iBase_FACE) {
      free(faces);
      free(dimensions);
      return FALSE;
    }
  }

  free(faces);
  free(dimensions);

  return TRUE;
}

/* make each topological entity vectors, check their topology */
/* types, get interior and exterior faces of hexes */
int topology_adjacency_test(iMesh_Instance mesh)
{
  int result, i, j, entities_alloc, entities_size, *topologies;
  int topologies_alloc, topologies_size;
  iBase_EntityHandle *entities, *entity_vectors[iMesh_ALL_TOPOLOGIES] = {NULL};
  int entity_vectors_sizes[iMesh_ALL_TOPOLOGIES] = {0};
  int top_j, num_tops, region_type, num_region;
  iBase_EntityHandle *adj_faces = NULL;
  int adj_faces_alloc = 0, adj_faces_size;
  int *face_offsets = NULL;
  int face_offsets_alloc = 0, face_offsets_size, face_loaded;
  iBase_EntityHandle *adj_regions = NULL;
  int adj_regions_alloc = 0, adj_regions_size;
  int *region_offsets = NULL;
  int region_offsets_alloc = 0, region_offsets_size;
  iBase_EntityHandle *interior, *exterior;
  int num_int = 0, num_ext = 0, found, next_offset, iter;
  int num_faces_per_region;;

    /* fill the vectors of each topology entities */
    /* like lines vector, polygon vector, triangle vector, */
    /* quadrilateral, polyhedrron, tet, hex, prism, pyramid, */
    /* septahedron vectors */
  for (i = 0; i < iMesh_ALL_TOPOLOGIES; i++) {
    entities = NULL;
    entities_alloc = 0;
    iMesh_getEntities(mesh, root_set, iBase_ALL_TYPES,
                      i, &entities, &entities_alloc, 
                      &entities_size, &result);
    if (iBase_SUCCESS != result) {
      printf("Failed to get entities in adjacencies_test.\n");
      return FALSE;
    }

    if (entities_alloc > 0) {
      topologies = NULL;
      topologies_alloc = 0;
      iMesh_getEntArrTopo(mesh, entities, 
                          entities_alloc, 
                          &topologies, &topologies_alloc, &topologies_size, &result);
      if (iBase_SUCCESS != result) {
        printf("Failed to get topologies in adjacencies_test.\n");
        return FALSE;
      }  

      if (topologies_size != entities_size) {
        printf("Didn't get the right number of topologies "
               "in topology_adjacency_test.\n");
        free(topologies);
        free(entities);
        return FALSE;
      }
    
        /* put entities into vectors of each topology */
      entity_vectors[i] = (iBase_EntityHandle*) 
        malloc(entities_size*sizeof(iBase_EntityHandle));

      for (j = 0; j < entities_size; j++) {
        if (topologies[j] < iMesh_POINT ||
            topologies[j] >= iMesh_ALL_TOPOLOGIES)
          printf("Didn't find entity type for this topology.");
        else {
          entity_vectors[i][entity_vectors_sizes[i]] = entities[j];
          entity_vectors_sizes[i]++;
        }
      }

      free(topologies);
    }

    free(entities);
  }

    /* check number of entities for each topology */
  for (top_j = 0; top_j < iMesh_ALL_TOPOLOGIES; top_j++) {
    num_tops = 0;
    iMesh_getNumOfTopo(mesh, root_set, top_j, &num_tops, &result);
    if (iBase_SUCCESS != result) {
      printf("Failed to get number of topologies in adjacencies_test.\n");
      for (i = 0; i < iMesh_ALL_TOPOLOGIES; i++)
        free(entity_vectors[i]);
      return FALSE;
    }
    
    if (entity_vectors_sizes[top_j] != num_tops) {
      printf("Topology count mismatch.\n");
      for (i = 0; i < iMesh_ALL_TOPOLOGIES; i++)
        free(entity_vectors[i]);
      return FALSE;
    }
  }

    /* change if 3d topology entities are added or removed */
  for (region_type = iMesh_TETRAHEDRON;
       region_type < iMesh_ALL_TOPOLOGIES; region_type++) {
      /* get all adjacent faces of regions  */
    iBase_EntityHandle *region_vector =
      entity_vectors[region_type];
    
    num_region = entity_vectors_sizes[region_type];
    
    if (num_region > 0) {
      adj_faces = NULL;
      adj_faces_alloc = 0;
      face_offsets = NULL;
      face_offsets_alloc = 0;
      
      iMesh_getEntArrAdj(mesh, region_vector, num_region, 
                         iBase_FACE,
                         &adj_faces, &adj_faces_alloc, &adj_faces_size, 
                         &face_offsets, &face_offsets_alloc, 
                         &face_offsets_size, &result);
      if (iBase_SUCCESS != result) {
        printf("Failed to get adjacent faces of regions in adjacencies_test.\n");
        for (i = 0; i < iMesh_ALL_TOPOLOGIES; i++)
          free(entity_vectors[i]);
        return FALSE;
      }

      if (num_region + 1 != face_offsets_size) {
        printf("Number of offsets didn't agree with number of "
               "regions in topology_adjacency_test.\n");
        free(face_offsets);
        free(adj_faces);
        for (i = 0; i < iMesh_ALL_TOPOLOGIES; i++)
          free(entity_vectors[i]);
        return FALSE;
      }

      face_loaded = FALSE;

        /* check # of faces really loaded */
      if (region_type == iMesh_TETRAHEDRON) {
        if (adj_faces_size == 4 * num_region)
          face_loaded = TRUE;
      }
      else if (region_type == iMesh_HEXAHEDRON) {
        if (adj_faces_size == 6 * num_region)
          face_loaded = TRUE;
      }
      else if (region_type == iMesh_PRISM) {
        if (adj_faces_size == 5 * num_region)
          face_loaded = TRUE;
      }
      else if (region_type == iMesh_PYRAMID) {
        if (adj_faces_size == 5 * num_region)
          face_loaded = TRUE;
      }
      else if (region_type == iMesh_SEPTAHEDRON) {
        if (adj_faces_size == 7 * num_region)
          face_loaded = TRUE;
      }
      else
        face_loaded = FALSE;

        /* get all adjacent regions of adjacent faces */
      adj_regions = NULL;
      adj_regions_alloc = 0;
      region_offsets = NULL;
      region_offsets_alloc = 0;
      iMesh_getEntArrAdj(mesh, adj_faces, adj_faces_size, iBase_REGION,
                         &adj_regions, &adj_regions_alloc, 
                         &adj_regions_size,
                         &region_offsets, &region_offsets_alloc,
                         &region_offsets_size, &result);
      if (iBase_SUCCESS != result) {
        printf("Failed to get regions from faces in adjacencies_test.\n");
        free(face_offsets);
        free(adj_faces);
        for (i = 0; i < iMesh_ALL_TOPOLOGIES; i++)
          free(entity_vectors[i]);
        return FALSE;
      }

      if (adj_faces_size + 1 != region_offsets_size) {
        printf("Number of offsets didn't agree with number of faces in topology_adjacency_test.\n");
        free(face_offsets);
        free(region_offsets);
        free(adj_faces);
        free(adj_regions);
        for (i = 0; i < iMesh_ALL_TOPOLOGIES; i++)
          free(entity_vectors[i]);
        return FALSE;
      }

      interior = (iBase_EntityHandle*)malloc(adj_faces_size*sizeof(iBase_EntityHandle)),
      exterior = (iBase_EntityHandle*)malloc(adj_faces_size*sizeof(iBase_EntityHandle));
      num_int = 0;
      num_ext = 0;

        /* find the interior faces having two adjacent regions */
      for (i = 0; i < adj_faces_size; i++) {
        next_offset = 0;
        if (i == adj_faces_size-1) next_offset = adj_regions_size;
        else next_offset = region_offsets[i + 1];

        if (next_offset - region_offsets[i] == 2) {
          found = FALSE;
          for (iter = 0; iter < num_int; iter++) {
            if (interior[iter] == adj_faces[i]) {
              found = TRUE;
              break;
            }
          }
          if (!found)
            interior[num_int++] = adj_faces[i];
        }
      }

        /* now remove any interior faces from the previous adjacent faces list */
        /* and we should be left with exterior faces */
      for (i = 0; i < adj_faces_size; i++) {
        found = FALSE;
        for (iter = 0; iter < num_int; iter++) {
          if (interior[iter] == adj_faces[i]) {
            found = TRUE;
            break;
          }
        }
        if (!found)
          exterior[num_ext++] = adj_faces[i];
      }

      num_faces_per_region = face_offsets[1] - face_offsets[0];

        /* check # of exterior and interior faces */
        /* should be #exterior_faces + 2 * #interior_faces = #faces_per_region */
        /* * #regions */
      if (face_loaded) {
        if (num_ext + 2*num_int !=
            num_faces_per_region*num_region) {
          printf("exterior/interior failure: %d ext, %d int, %d regions, %d faces per\n",
                 num_ext, num_int, num_region, num_faces_per_region);
          free(face_offsets);
          free(region_offsets);
          free(adj_faces);
          free(adj_regions);
          free(interior);
          free(exterior);
          for (i = 0; i < iMesh_ALL_TOPOLOGIES; i++)
            free(entity_vectors[i]);
          return FALSE;
        }
      }

      free(face_offsets);
      free(region_offsets);
      free(adj_faces);
      free(adj_regions);
      free(interior);
      free(exterior);
    }
  }

  for (i = 0; i < iMesh_ALL_TOPOLOGIES; i++)
    free(entity_vectors[i]);

  return TRUE;
}

int qsort_comp_handles( const void* h1, const void* h2 )
{
  return *(char**)h1 - *(char**)h2;
}

int entity_connectivity_test(iMesh_Instance mesh)
{
  int type, result;
  int *offsets, offsets_alloc, offsets_size;
  int *indices, indices_alloc, indices_size;
  iBase_EntityHandle *entities, *adj_ents, *entities2, *sorted;
  int entities_alloc, entities_size, adj_ents_alloc, adj_ents_size;
  int entities2_alloc, entities2_size;
  iBase_EntityHandle adj_ents2[27], *adj_ents2_ptr = adj_ents2;
  int adj_ents2_alloc = 27, adj_ents2_size, i, size;

  for (type = iBase_EDGE; type < iBase_ALL_TYPES; type++) {
    entities = NULL; entities_alloc = 0;
    adj_ents = NULL; adj_ents_alloc = 0;
    indices = NULL; indices_alloc = 0;
    offsets = NULL; offsets_alloc = 0;
    iMesh_getAdjEntIndices( mesh, root_set, 
                            type, iMesh_ALL_TOPOLOGIES, iBase_VERTEX,
                            &entities, &entities_alloc, &entities_size,
                            &adj_ents, &adj_ents_alloc, &adj_ents_size,
                            &indices, &indices_alloc, &indices_size,
                            &offsets, &offsets_alloc, &offsets_size,
                            &result );
    if (iBase_SUCCESS != result) {
      printf("Failed to get indices of vertices in connectivity_test, type=%d.\n", type);
      return FALSE;
    }

    if (entities_alloc != entities_size) {
      printf("Number of entities didn't agree with array size in connectivity_test.\n");
      free(entities);
      free(adj_ents);
      free(indices);
      free(offsets);
      return FALSE;
    }

    if (offsets_alloc != offsets_size) {
      printf("Number of offsets didn't agree with array size in connectivity_test.\n");
      free(entities);
      free(adj_ents);
      free(indices);
      free(offsets);
      return FALSE;
    }

    if (indices_alloc != indices_size) {
      printf("Number of indices didn't agree with array size in connectivity_test.\n");
      free(entities);
      free(adj_ents);
      free(indices);
      free(offsets);
      return FALSE;
    }

    if (adj_ents_alloc != adj_ents_size) {
      printf("Number of adjacent entities didn't agree with array size in connectivity_test.\n");
      free(entities);
      free(adj_ents);
      free(indices);
      free(offsets);
      return FALSE;
    }
    
    if (offsets_size != entities_size + 1) {
      printf("Invalid/inconsistent offset size from iMesh_getAdjEntIndices.\n");
      free(entities);
      free(adj_ents);
      free(indices);
      free(offsets);
      return FALSE;
    }

      /* check that results are valid */
    for (i = 0; i < entities_size; ++i) {
      ASSERT( offsets[i] < offsets[i + 1] && offsets[i] < indices_size );
      if (!assert_pass) {
        free(entities);
        free(adj_ents);
        free(indices);
        free(offsets);
        return FALSE;
      }
    }

    for (i = 0; i < indices_size; ++i) {
      ASSERT( indices[i] >= 0 && indices[i] < adj_ents_size );
      if (!assert_pass) {
        free(entities);
        free(adj_ents);
        free(indices);
        free(offsets);
        return FALSE;
      }
    }
    
      /* compare initial entity list against result of iMesh_getEntities */
    entities2 = NULL; entities2_alloc = 0;
    iMesh_getEntities( mesh, root_set, 
                       type, iMesh_ALL_TOPOLOGIES,
                       &entities2, &entities2_alloc, &entities2_size,
                       &result );
    ASSERT( iBase_SUCCESS == result );
    if (!assert_pass) {
      free(entities);
      free(adj_ents);
      free(indices);
      free(offsets);
      return FALSE;
    }

    size = sizeof(iBase_EntityHandle)*entities_size;
    sorted = (iBase_EntityHandle*)malloc(size);
    memcpy( sorted, entities, size );
    qsort( sorted, entities_size, sizeof(iBase_EntityHandle), &qsort_comp_handles );
    qsort( entities2, entities2_size, sizeof(iBase_EntityHandle), &qsort_comp_handles );

    ASSERT( entities_size == entities2_size && !memcmp(sorted, entities2, size) );
    if (!assert_pass) {
      free(entities);
      free(adj_ents);
      free(indices);
      free(offsets);
      free(entities2);
      free(sorted);
      return FALSE;
    }

    free(entities2);
    free(sorted);

      /* compare results against output of iMesh_getEntAdj */
    for (i = 0; i < entities_size; ++i) {
      iMesh_getEntAdj( mesh, entities[i], iBase_VERTEX,
                       &adj_ents2_ptr, &adj_ents2_alloc, &adj_ents2_size,
                       &result );
      ASSERT( iBase_SUCCESS == result );
      if (!assert_pass) {
        free(entities);
        free(adj_ents);
        free(indices);
        free(offsets);
        return FALSE;
      }

      ASSERT( adj_ents2_ptr == adj_ents2 ); /* shouldn't change */
      if (!assert_pass) {
        free(entities);
        free(adj_ents);
        free(indices);
        free(offsets);
        return FALSE;
      }

      ASSERT( adj_ents2_alloc == 27 ); /* shouldn't change */
      if (!assert_pass) {
        free(entities);
        free(adj_ents);
        free(indices);
        free(offsets);
        return FALSE;
      }

      /* compare results */
      size = offsets[i + 1] - offsets[i];
      ASSERT( size == adj_ents2_size );
      while (--size >= 0) {
        ASSERT( adj_ents2[size] == adj_ents[indices[offsets[i] + size]] );
        if (!assert_pass) {
          free(entities);
          free(adj_ents);
          free(indices);
          free(offsets);
          return FALSE;
        }
      }
    }

    free(entities);
    free(adj_ents);
    free(indices);
    free(offsets);

/*
    offsets = NULL;
    offsets_alloc = 0;
    entities = NULL;
    entities_alloc = 0;

    iMesh_getAdjEntities(mesh, root_set, type, 
                         iMesh_ALL_TOPOLOGIES, iBase_VERTEX, 
                         &entities, &entities_alloc, &entities_size,
                         &offsets, &offsets_alloc, &offsets_size,
                         &result);
    if (iBase_SUCCESS != result) {
      printf("Failed to get indices of adjacent entity vertices in connectivity_test.\n");
      return FALSE;
    }

    if (entities_alloc != entities_size ||
        offsets_alloc != offsets_size) {
      printf("Number of elements didn't agree with array size for an array in connectivity_test.\n");
      return FALSE;
    }

    free(offsets);
    free(entities);
*/
  }

  return TRUE;
}

/* helper function used to report errors in # sets */
int check_esets(iMesh_Instance mesh, const int num_sets);

int entity_sets_subtest(iMesh_Instance mesh, int is_list,
                         int /*num_iter*/)
{
  int i, num_type = iBase_ALL_TYPES - iBase_VERTEX;
  int num_all_entities_super = 0;
  iBase_EntitySetHandle es_array[iBase_ALL_TYPES - iBase_VERTEX];
  int number_array[iBase_ALL_TYPES - iBase_VERTEX];
  int ent_type = iBase_VERTEX;
  iBase_EntityHandle *entities = NULL;
  int entities_alloc = 0, entities_size;
  iBase_EntitySetHandle parent_child, super_set = NULL;
  iBase_EntitySetHandle temp_es1, temp_es2, temp_es3;
  iBase_EntityHandle *edges = NULL, *faces = NULL, 
    *temp_entities1 = NULL, *temp_entities2 = NULL;
  int edges_alloc = 0, faces_alloc = 0, 
    temp_entities1_alloc = 0, temp_entities2_alloc = 0;
  int edges_size, faces_size, temp_entities1_size, temp_entities2_size;
  int *types = NULL;
  int types_alloc = 0, types_size;
  int num_rest, num_regions;
  iBase_EntityHandle *regions = NULL;
  int regions_alloc = 0, regions_size;
  iBase_EntitySetHandle *parents = NULL;
  int parents_alloc = 0, parents_size, temp_numb, is_child;
  iBase_EntitySetHandle *es_array1 = NULL;
  int es_array1_alloc = 0, es_array1_size, num_super;
  iBase_EntityHandle *all_entities = NULL;
  int all_entities_alloc = 0, all_entities_size, k, l;
  iBase_EntityHandle *adj_faces = NULL;
  int adj_faces_alloc = 0, adj_faces_size;
  int *face_offsets = NULL;
  int face_offsets_alloc = 0, face_offsets_size;
  iBase_EntityHandle *hexes = NULL;
  int hexes_alloc = 0, hexes_size;
  iBase_EntitySetHandle hex_set;

    /* get the number of whole mesh */
  int n_whole_mesh = 0;
  int result;
  iMesh_getNumEntSets(mesh, root_set, 1, &n_whole_mesh, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem to get the number of all entity sets in whole mesh.\n");
    return FALSE;
  }

    /* add entities to entitysets by type */
  for (; ent_type < num_type; ent_type++) {
      /* initialize the entityset */
    iMesh_createEntSet(mesh, is_list, &es_array[ent_type], &result);
    if (iBase_SUCCESS != result) {
      printf("Problem creating entityset.\n");
      return FALSE;
    }

      /* get entities by type in total "mesh" */
    entities = NULL;
    entities_alloc = 0;
    iMesh_getEntities(mesh, root_set, ent_type,
                      iMesh_ALL_TOPOLOGIES, 
                      &entities, &entities_alloc, &entities_size, &result);
    if (iBase_SUCCESS != result) {
      printf("Failed to get entities by type in entity_sets_test.\n");
      return FALSE;
    }

    if (entities_alloc != entities_size) {
      printf("Number of entities didn't agree with array size in entity_sets_subtest.\n");
      free(entities);
      return FALSE;
    }

      /* add entities into entity set */
    if (0 != entities_size) {
      iMesh_addEntArrToSet(mesh, entities, entities_size, es_array[ent_type], &result);
      if (iBase_SUCCESS != result) {
        printf("Failed to add entities in entity_sets_test.\n");
        free(entities);
        return FALSE;
      }
    }
    
      /* Check to make sure entity set really has correct number of entities in it */
    iMesh_getNumOfType(mesh, es_array[ent_type], ent_type,
                       number_array + ent_type, &result);
      
    if (iBase_SUCCESS != result) {
      printf("Failed to get number of entities by type in entity_sets_test.\n");
      free(entities);
      return FALSE;
    }  

      /* compare the number of entities by type */
    if (number_array[ent_type] != entities_size)
    {
      printf("Number of entities by type is not correct\n");
      free(entities);
      return FALSE;
    }

      /* add to number of all entities in super set */
    num_all_entities_super += entities_size;

    free(entities);
  }

  if (!check_esets(mesh, n_whole_mesh + num_type))
    return FALSE;

    /* make a super set having all entitysets */
  super_set = NULL;
  iMesh_createEntSet(mesh, is_list, &super_set, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to create a super set in entity_sets_test.\n");
    return FALSE;
  }

  for (i = 0; i < num_type; i++) {
    iMesh_addEntSet(mesh, es_array[i], super_set, &result);
    if (iBase_SUCCESS != result) {
      printf("Failed to add a set to a super set in entity_sets_test.\n");
      return FALSE;
    }
  }
  
  if (!check_esets(mesh, n_whole_mesh + num_type + 1)) 
    return FALSE;

    /*----------TEST intEAN OPERATIONS----------------*/

  iMesh_createEntSet(mesh, is_list, &temp_es1, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to create a super set in entity_sets_test.\n");
    return FALSE;
  }
  
  if (!check_esets(mesh, n_whole_mesh + num_type + 2)) {
    return FALSE;
  }

    /* Subtract */
    /* add all EDGEs and FACEs to temp_es1 */
    /* get all EDGE entities */
  edges = NULL;
  edges_alloc = 0;
  iMesh_getEntities(mesh, es_array[iBase_EDGE], iBase_EDGE, 
                    iMesh_ALL_TOPOLOGIES, 
                    &edges, &edges_alloc, &edges_size, &result);

  if (iBase_SUCCESS != result) {
    printf("Failed to get edge entities in entity_sets_test.\n");
    return FALSE;
  }

    /* add EDGEs to es1 */
  iMesh_addEntArrToSet(mesh, edges, edges_size, temp_es1, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to add edge entities in entity_sets_test.\n");
    free(edges);
    return FALSE;
  }

    /* get all FACE entities */
  faces = NULL;
  faces_alloc = 0;
  iMesh_getEntities(mesh, es_array[iBase_FACE], iBase_FACE, 
                    iMesh_ALL_TOPOLOGIES, 
                    &faces, &faces_alloc, &faces_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get face entities in entity_sets_test.\n");
    free(edges);
    return FALSE;
  }

    /* add FACEs to es1 */
  iMesh_addEntArrToSet(mesh, faces, faces_size, temp_es1, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to add face entities in entity_sets_test.\n");
    free(edges);
    free(faces);
    return FALSE;
  }

    /* subtract EDGEs */
  
  iMesh_subtract(mesh, temp_es1, es_array[iBase_EDGE], &temp_es2, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to subtract entitysets in entity_sets_test.\n");
    free(edges);
    free(faces);
    return FALSE;
  }

  temp_entities1 = NULL;
  temp_entities1_alloc = 0;
  iMesh_getEntities(mesh, temp_es2, iBase_FACE, iMesh_ALL_TOPOLOGIES, 
                    &temp_entities1, &temp_entities1_alloc, &temp_entities1_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get face entities in entity_sets_test.\n");
    free(edges);
    free(faces);
    return FALSE;
  }

  if (faces_size != temp_entities1_size) {
    printf("not match number of entitysets after subtraction "
           "in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    return FALSE;
  }

    /* check there's nothing but faces in face_es */
  types = NULL;
  types_alloc = 0;
  iMesh_getEntArrType(mesh, temp_entities1, temp_entities1_size,
                      &types, &types_alloc, &types_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get types of entities in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    return FALSE;
  }
  for (i = 0; i < types_size; i++) {
    if (types[i] != iBase_FACE) {
      printf("wrong entity type for face test in entity_sets_test.\n");
      free(edges);
      free(faces);
      free(temp_entities1);
      free(types);
      return FALSE;
    }
  }

  iMesh_destroyEntSet(mesh, temp_es2, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to destroy temp es2.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(types);
    return FALSE;
  }
    
  if (!check_esets(mesh, n_whole_mesh + num_type + 2)) {
    free(edges);
    free(faces);
    free(temp_entities1);
    free(types);
    return FALSE;
  }

    /*------------Intersect------------ */

    /* clean out the temp_ms1 */
  iMesh_rmvEntArrFromSet(mesh, faces, faces_size, temp_es1, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to remove face entities in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(types);
    return FALSE;
  }

    /* check if it is really cleaned out */
  iMesh_getNumOfType(mesh, temp_es1, iBase_FACE, &num_rest, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get number of entities by type in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(types);
    return FALSE;
  }

  if (num_rest != 0) {
    printf("failed to remove correctly.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(types);
    return FALSE;
  }
  
    /* add EDGEs to temp es1 */
  iMesh_addEntArrToSet(mesh, edges, edges_size, temp_es1, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to add edge entities in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(types);
    return FALSE;
  }

    /* add FACEs to temp es1 */
  iMesh_addEntArrToSet(mesh, faces, faces_size, temp_es1, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to add edge entities in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(types);
    return FALSE;
  }

    /* intersect temp_es1 with edges meshset  */
    /* temp_ms1 entityset is altered */
  iMesh_intersect(mesh, temp_es1, es_array[iBase_EDGE], &temp_es2, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to intersect in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(types);
    return FALSE;
  }

  temp_entities2 = NULL;
  temp_entities2_alloc = 0;
  iMesh_getEntities(mesh, temp_es2, iBase_FACE, iMesh_ALL_TOPOLOGIES, 
                    &temp_entities2, &temp_entities2_alloc, 
                    &temp_entities2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get face entities in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(types);
    return FALSE;
  }

  if (temp_entities2_size != 0) {
    printf("wrong number of faces.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    return FALSE;
  }

  iMesh_destroyEntSet(mesh, temp_es2, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to destroy temp es2.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    return FALSE;
  }
    
  if (!check_esets(mesh, n_whole_mesh + num_type + 2)) {
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    return FALSE;
  }

    /*-------------Unite-------------- */

  iMesh_createEntSet(mesh, is_list, &temp_es2, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to create a temp entityset in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    return FALSE;
  }

  /* get all regions */
  regions = NULL;
  regions_alloc = 0;
  iMesh_getEntities(mesh, es_array[iBase_REGION], 
                    iBase_REGION, 
                    iMesh_ALL_TOPOLOGIES, 
                    &regions, &regions_alloc, &regions_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get region entities in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    return FALSE;
  }

    /* add REGIONs to temp es2 */
  iMesh_addEntArrToSet(mesh, regions, regions_size, temp_es2, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to add region entities in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    return FALSE;
  }

    /* unite temp_es1 and temp_es2 */
  iMesh_unite(mesh, temp_es1, temp_es2, &temp_es3, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to unite in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    return FALSE;
  }

    /* perform the check */
  iMesh_getNumOfType(mesh, temp_es3, iBase_REGION, &num_regions, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get number of region entities by type in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    return FALSE;
  }
  
  if (num_regions != number_array[iBase_REGION]) {
    printf("different number of regions in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    return FALSE;
  }

  if (!check_esets(mesh, n_whole_mesh + num_type + 4)) {
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    return FALSE;
  }

    /*--------Test parent/child stuff in entiysets----------- */

    /* Add 2 meshsets as children to another */
  iMesh_createEntSet(mesh, is_list, &parent_child, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem creating entityset in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    return FALSE;
  }

  iMesh_addPrntChld(mesh, es_array[iBase_VERTEX], parent_child, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem add parent in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    return FALSE;
  }

    /* check if parent is really added */
  parents = NULL;
  parents_alloc = 0;
  iMesh_getPrnts(mesh, parent_child, 0, 
                 &parents, &parents_alloc, &parents_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem getting parents in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    return FALSE;
  }

  if (parents_size != 1) {
    printf("number of parents is not correct in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    return FALSE;
  }

    /* get the number of child entitysets */
  iMesh_getNumChld(mesh, es_array[iBase_VERTEX], 0, &temp_numb, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem getting number of children in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    return FALSE;
  }

  if (temp_numb != 1) {
    printf("number of children is not correct in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    return FALSE;
  }

    /* parent_child and es_array[iBase_VERTEX] should be related */
  is_child = 0;
  iMesh_isChildOf(mesh, es_array[iBase_VERTEX], parent_child, &is_child, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem checking relation in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    return FALSE;
  }
  if (!is_child) {
    printf("parent_child and es_array[iBase_VERTEX] should be related\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    return FALSE;
  }
    
    /* es_array[iBase_FACE] and es_array[iBase_REGION] are not related */
  is_child = FALSE;
  iMesh_isChildOf(mesh, es_array[iBase_FACE], es_array[iBase_REGION], &is_child, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem checking relation in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    return FALSE;
  }
  if (is_child) {
    printf("es_array[iBase_REGION] and es_array[iBase_FACE] should not be related\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    return FALSE;
  }
  
  if (!check_esets(mesh, n_whole_mesh + num_type + 5)) {
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    return FALSE;
  }

    /*--------test modify and query functions----------------------------- */
  
    /* get all entity sets in super set */
  es_array1 = NULL;
  es_array1_alloc = 0;
  iMesh_getEntSets(mesh, super_set, 0, 
                   &es_array1, &es_array1_alloc, &es_array1_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem to get entity sets in super set.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    return FALSE;
  }

    /* get the number of entity sets in super set */
  iMesh_getNumEntSets(mesh, super_set, 0, &num_super, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem to get the number of all entity sets in super set.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    free(es_array1);
    return FALSE;
  }

    /* the number of entity sets in super set should be same */
  if (num_super != es_array1_size) {
    printf("the number of entity sets in super set should be same.\n");
    return FALSE;
  }

    /* get all entities in super set */
  all_entities = NULL;
  all_entities_alloc = 0;
  iMesh_getEntities(mesh, super_set, iBase_ALL_TYPES,
                    iMesh_ALL_TOPOLOGIES, 
                    &all_entities, &all_entities_alloc, &all_entities_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem to get all entities in super set.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    free(es_array1);
    return FALSE;
  }
  
    /* compare the number of all entities in super set */
    /* NOTE: TEST COMMENTED OUT UNTIL RESOLUTION OF WHETHER GETENTITIES */
    /* SHOULD GET A NUM_HOPS ARGUMENT */
    /*  if (num_all_entities_super != all_entities_size) { */
    /*    printf("number of all entities in super set should be same.\n"); */
    /*    return FALSE; */
    /*  } */

    /* test add, remove and get all entitiy sets using super set */
    /* check GetAllEntitySets works recursively and dosen't return */
    /* multi sets */
  for (k = 0; k < num_super; k++) {
      /* add entity sets of super set to each entity set of super set */
      /* make multiple child super sets */
    iBase_EntitySetHandle es_k = es_array1[k];
    for (l = 0; l < es_array1_size; l++) {
      iMesh_addEntSet(mesh, es_array1[l], es_k, &result);
      if (iBase_SUCCESS != result) {
        printf("Problem to add entity set to entityset.\n");
        free(edges);
        free(faces);
        free(temp_entities1);
        free(temp_entities2);
        free(types);
        free(regions);
        free(parents);
        free(es_array1);
        free(all_entities);
        return FALSE;
      }
    }

      /* add super set to each entity set */
    iMesh_addEntSet(mesh, super_set, es_k, &result);
    if (iBase_SUCCESS != result) {
      printf("Problem to add super set to entitysets.\n");
      free(edges);
      free(faces);
      free(temp_entities1);
      free(temp_entities2);
      free(types);
      free(regions);
      free(parents);
      free(es_array1);
      free(all_entities);
      return FALSE;
    }

      /* add one entity sets multiple times */
    for (l = 0; l < 3; l++) {
      iMesh_addEntSet(mesh, temp_es1, es_k, &result);
      if (iBase_SUCCESS != result) {
        printf("Problem to add temp set to entitysets.\n");
        free(edges);
        free(faces);
        free(temp_entities1);
        free(temp_entities2);
        free(types);
        free(regions);
        free(parents);
        free(es_array1);
        free(all_entities);
        return FALSE;
      }
    }
  }

    /* get all hexes and get faces of that hexes */
  hexes = NULL;
  hexes_alloc = 0;

  iMesh_getEntities(mesh, root_set, iBase_ALL_TYPES,
                    iMesh_HEXAHEDRON, &hexes, &hexes_alloc, &hexes_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get hexes in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    free(es_array1);
    free(all_entities);
    return FALSE;
  }

    /* get adjacent face of hexes */
  adj_faces = NULL;
  adj_faces_alloc = 0;
  face_offsets = NULL; 
  face_offsets_alloc = 0; 

  iMesh_getEntArrAdj( mesh, hexes, hexes_size, iBase_FACE,
                      &adj_faces, &adj_faces_alloc, &adj_faces_size,
                      &face_offsets, &face_offsets_alloc, &face_offsets_size,
                      &result);
  if (iBase_SUCCESS != result) {
    printf("Problem to get adjacent entities in entitysets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    free(es_array1);
    free(all_entities);
    free(hexes);
    return FALSE;
  }

  iMesh_createEntSet(mesh, FALSE, &hex_set, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem creating entityset in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    free(es_array1);
    free(all_entities);
    free(hexes);
    free(adj_faces);
    free(face_offsets);
    return FALSE;
  }
  
  iMesh_addEntArrToSet(mesh, hexes, hexes_size, hex_set, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to add hexes in entity_sets_test.\n");
    free(edges);
    free(faces);
    free(temp_entities1);
    free(temp_entities2);
    free(types);
    free(regions);
    free(parents);
    free(es_array1);
    free(all_entities);
    free(hexes);
    free(adj_faces);
    free(face_offsets);
    return FALSE;
  }
  
  free(edges);
  free(faces);
  free(temp_entities1);
  free(temp_entities2);
  free(types);
  free(regions);
  free(parents);
  free(es_array1);
  free(all_entities);
  free(hexes);
  free(adj_faces);
  free(face_offsets);

  return TRUE;
}

int check_esets(iMesh_Instance mesh, const int num_sets) 
{
  int entity_sets_size;

  int result;
  iMesh_getNumEntSets(mesh, root_set, 1, &entity_sets_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Problem to get all entity sets in mesh.\n");
    return FALSE;
  }
  if (entity_sets_size != num_sets) {
    printf("the number of entity sets in whole mesh should be %d"
           ", actual number is %d.\n", num_sets, entity_sets_size);
    return FALSE;
  }

  return TRUE;
}

int entity_sets_test(iMesh_Instance mesh)
{
  int iter_num = 0, result;
    /* check  */
  int i;
  for (i = 0; i < 2; i++) {
    iter_num++;

    result = entity_sets_subtest(mesh, i, iter_num);
    if (!result)
      return result;
  }
  
  return TRUE;
}

int vertex_coordinates_test(iMesh_Instance mesh)
{
  iBase_EntityHandle *verts = NULL;
  int verts_alloc = 0, verts_size;
  double *vert_coords = NULL;
  int vert_coords_alloc = 0, vert_coords_size;

    /* check storage order */
  int result;
  int this_order;
  iMesh_getDfltStorage(mesh, &this_order, &result);
  if (iBase_SUCCESS != result) {
    printf("failed to get preferred storage order in vertex_coordinates_test.\n");
    return FALSE;
  }

    /* now get the vertex coordinates from a vertex array */
    /* need to get the vertices in the model */
  verts = NULL;
  verts_alloc = 0;
  iMesh_getEntities(mesh, root_set, iBase_VERTEX, 
                    iMesh_POINT, &verts, &verts_alloc, &verts_size, &result);
  if (iBase_SUCCESS != result) {
    printf("failed to get entities in vertex_coordinates_test.\n");
    return FALSE;
  }

    /* get the coordinates in one array */
  vert_coords = NULL;
  vert_coords_alloc = 0;

  iMesh_getVtxArrCoords(mesh, verts, verts_size, iBase_INTERLEAVED, 
                        &vert_coords, &vert_coords_alloc, &vert_coords_size, &result);
  if (iBase_SUCCESS != result) {
    printf("failed to get vertex cooridinate of entities in vertex_coordinates_test.\n");
    free(verts);
    return FALSE;
  }

  free(verts);
  free(vert_coords);
  
    /* if we get here, this test was successful */
  return TRUE;
}

int tag_info_test(iMesh_Instance mesh)
{
  char dum_name[120];
  int dum_name_size = 120;
  int dum_size;
  int error = FALSE;
  iBase_TagHandle dum_handle;
    /* Create a tag */
  int result;
  iBase_TagHandle tag_handle = NULL;
  const char *tag_name = "int_tag";
  int tag_name_size = 8;
  iMesh_createTag(mesh, tag_name, 1, iBase_INTEGER, 
                  &tag_handle, &result, tag_name_size);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag int_tag in vertex_tag_test.");
    return FALSE;
  }

    /* check tag info functions */
  iMesh_getTagName(mesh, tag_handle, dum_name, &result, dum_name_size);
  if (iBase_SUCCESS != result) {
    printf("Couldn't get name of tag just created.\n");
    return FALSE;
  }
  if (strcmp(dum_name, "int_tag")) {
    printf("Tag names didn't match.\n");
    return FALSE;
  }
  
  iMesh_getTagSizeBytes(mesh, tag_handle, &dum_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't get size of tag just created.\n");
    return FALSE;
  }
  if (dum_size != sizeof(int)) {
    printf("Tag sizes didn't match.\n");
    return FALSE;
  }

  iMesh_getTagHandle(mesh, tag_name, &dum_handle, &result, tag_name_size);
  if (iBase_SUCCESS != result) {
    printf("Couldn't get handle of tag just created.\n");
    return FALSE;
  }
  if (dum_handle != tag_handle) {
    printf("Tag handles didn't match.\n");
    return FALSE;
  }

    /* test non-forced version of tagDelete; forced version tested later, */
    /* when we have entities around */
  iMesh_destroyTag(mesh, tag_handle, FALSE, &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't delete tag just created.\n");
    return FALSE;
  }

    /* look for that tag, to make sure it got deleted */
  iMesh_getTagHandle(mesh, tag_name, &tag_handle, &result, tag_name_size);
  if (iBase_SUCCESS != result) {
    error = TRUE;
  }
  if (!error) {
    printf("tagGetHandle was able to find handle for deleted tag.\n");
    return FALSE;
  }

  return TRUE;
}

int vertex_int_tag_test(iMesh_Instance mesh, 
                         iBase_EntityHandle *verts, int /*verts_size*/,
                         iBase_TagHandle *int_tag) 
{
  int result;
  iBase_EntityHandle dum_vert = verts[0];
  
  int dum_val = 11, dum_val2;
  void *dum_val2_ptr = &dum_val2;
  int dum_val2_alloc = sizeof(int), dum_val2_size;

    /* create a tag */
  const char *tag_name = "int_tag";
  int tag_name_size = 8;
  iMesh_createTag(mesh, tag_name, 1, iBase_INTEGER, 
                  int_tag, &result, tag_name_size);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag int_tag in vertex_int_tag_test.\n");
    return FALSE;
  }

    /* put a value in the first vertex and retrieve */
  iMesh_setArrData(mesh, &dum_vert, 1, *int_tag, 
                   (const char*)(&dum_val), sizeof(int), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set int tag (val=11) in vertex_int_tag_test.\n");
    return FALSE;
  }

  iMesh_getArrData(mesh, &dum_vert, 1, *int_tag,
                   &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result || dum_val2 != 11) {
    printf("Failed to get int tag (val=11) in vertex_int_tag_test.\n");
    return FALSE;
  }

  if (dum_val2 != 11) {
    
    printf("Value of vertex tag (val=11) wrong.\n");
    return FALSE;
  }

    /* put a value in the last vertex and retrieve */
  dum_val = 12;

  iMesh_setArrData(mesh, &dum_vert, 1, *int_tag, 
                   (char*)(&dum_val), sizeof(int), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set int tag (val=12) in vertex_int_tag_test.\n");
    return FALSE;
  }

  iMesh_getArrData(mesh, &dum_vert, 1, *int_tag,
                   &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get int tag (val=12) in vertex_int_tag_test.\n");
    return FALSE;
  }

  if (dum_val2 != 12) {
    
    printf("Value of vertex tag (val=12) wrong.\n");
    return FALSE;
  }

    /* ok, the int tag test worked */
  return TRUE;
}

int vertex_double_tag_test(iMesh_Instance mesh, 
                            iBase_EntityHandle *verts, int  /*verts_size*/,
                            iBase_TagHandle *double_tag) 
{
  int result;

  iBase_EntityHandle dum_vert = verts[0];
  double dum_val = 1.0e6, dum_val2;
  void *dum_val2_ptr = &dum_val2;
  int dum_val2_alloc = sizeof(double), dum_val2_size;
  
    /* create a tag */
  const char *tag_name = "double_tag";
  int tag_name_size = 11;
  iMesh_createTag(mesh, tag_name, 1, iBase_DOUBLE, 
                  double_tag, &result, tag_name_size);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag double_tag in vertex_double_tag_test.\n");
    return FALSE;
  }

    /* put a value in the first vertex and retrieve */
  iMesh_setArrData(mesh, &dum_vert, 1, *double_tag, 
                   (char*)(&dum_val), sizeof(double), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set double tag (val=1.0e6) in vertex_double_tag_test.\n");
    return FALSE;
  }

  iMesh_getArrData(mesh, &dum_vert, 1, *double_tag,
                   &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get double tag (val=1.0e6) in vertex_double_tag_test.\n");
    return FALSE;
  }

  if (dum_val2 != 1.0e6) {
    printf("Value of vertex tag (val=1.0e6) wrong.\n");
    return FALSE;
  }

    /* put a value in the last vertex and retrieve */
  dum_val = 2.0e9;

  iMesh_setArrData(mesh, &dum_vert, 1, *double_tag, 
                   (char*)(&dum_val), sizeof(double), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set double tag (val=2.0e9) in vertex_double_tag_test.\n");
    return FALSE;
  }

  iMesh_getArrData(mesh, &dum_vert, 1, *double_tag,
                   &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get double tag (val=2.0e9) in vertex_double_tag_test.\n");
    return FALSE;
  }

  if (dum_val2 != 2.0e9) {
    printf("Value of vertex tag (val=2.0e9) wrong.\n");
    return FALSE;
  }

    /* ok, the double tag test worked */
  return TRUE;
}

  /* Add a struct Vertex Tag to the database */
struct TagStruct {
  double test_double;
  int test_int1, test_int2;
};

int vertex_struct_tag_test(iMesh_Instance mesh, 
                            iBase_EntityHandle *verts, int /*verts_size*/,
                            iBase_TagHandle *struct_tag) 
{
  int result;
  iBase_EntityHandle dum_vert = verts[0];
  struct TagStruct dum_struct = {3.0e12, 2, 3}, dum_struct2;
  void *dum_struct2_ptr = &dum_struct2;
  int dum_struct_alloc = sizeof(struct TagStruct), dum_struct_size;

    /* create a tag */
  const char *tag_name = "struct_tag";
  int tag_name_size = 11;
  iMesh_createTag(mesh, tag_name, sizeof(struct TagStruct), 
                  iBase_BYTES, struct_tag, &result, tag_name_size);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag struct_tag in vertex_struct_tag_test.\n");
    return FALSE;
  }

    /* put a value in the first vertex and retrieve */

    /* careful setting the value, since tags are opaque */
  iMesh_setArrData(mesh, &dum_vert, 1, *struct_tag, 
                   (const char*) &dum_struct, sizeof(struct TagStruct), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set struct tag in vertex_struct_tag_test.\n");
    return FALSE;
  }

  iMesh_getArrData(mesh, &dum_vert, 1, *struct_tag,
                   &dum_struct2_ptr, &dum_struct_alloc, &dum_struct_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get struct tag in vertex_struct_tag_test.\n");
    return FALSE;
  }

  if (dum_struct_size != sizeof(struct TagStruct)) {
    printf("Size of vertex struct tag wrong.\n");
    return FALSE;
  }
  if (dum_struct2.test_int1 != dum_struct.test_int1 ||
     dum_struct2.test_int2 != dum_struct.test_int2 ||
     dum_struct2.test_double != dum_struct.test_double) {
    printf("Value of vertex struct tag wrong.\n");
    return FALSE;
  }

    /* ok, the int tag test worked */
  return TRUE;
}

int vertex_tag_delete_test(iMesh_Instance mesh, 
                            iBase_EntityHandle *verts, int /*verts_size*/)
{
  int result;
  int delete_err = FALSE;

    /* test forced, unforced deletion of tags from entities */

    /* test getAlliBase_TagHandles for first entity */
  iBase_TagHandle *all_tags = NULL;
  iBase_EntityHandle dum_entity = verts[0];
  int all_tags_alloc = 0, all_tags_size;
  iMesh_getAllTags(mesh, verts[0], &all_tags, &all_tags_alloc,
                   &all_tags_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't get all tag handles from vertex.\n");
    return FALSE;
  }

  iMesh_rmvArrTag(mesh, &dum_entity, 1, all_tags[0], &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't remove tag from vertex.\n");
    free(all_tags);
    return FALSE;
  }
  
  iMesh_destroyTag(mesh, all_tags[1], FALSE, &result);
  if (iBase_SUCCESS != result) {
    delete_err = TRUE;
  }
  if (!delete_err) {
    printf("Error when unforced-deleting tag in use on a vertex.\n");
    free(all_tags);
    return FALSE;
  }

  iMesh_destroyTag(mesh, all_tags[1], TRUE, &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't force-delete a tag in use on a vertex.\n");
    free(all_tags);
    return FALSE;
  }

  free(all_tags);

    /* ok, we're done */
  return TRUE;
}

int vertex_tag_test(iMesh_Instance mesh)
{
  int result;

  iBase_TagHandle int_tag, double_tag, struct_tag;
  int int_err, double_err, struct_err, tag_delete_err;

  int info_err = tag_info_test(mesh);
  
    /* get all the vertices */
  iBase_EntityHandle *verts = NULL;
  int verts_alloc = 0, verts_size;
  iMesh_getEntities(mesh, root_set, iBase_ALL_TYPES, 
                    iMesh_POINT, &verts, &verts_alloc, &verts_size, &result);
  if (iBase_SUCCESS != result) {
    printf("entitysetGetEntities failed in vertex_tag_test.\n");
    return FALSE;
  }
  
    /* vertex int tag */
  int_err = vertex_int_tag_test(mesh, verts, verts_size, &int_tag);
  
    /* vertex double tag */
  double_err = vertex_double_tag_test(mesh, verts, verts_size, 
                                           &double_tag);
  
    /* vertex struct tag */
  struct_err = vertex_struct_tag_test(mesh, verts, verts_size, 
                                           &struct_tag);

  tag_delete_err = vertex_tag_delete_test(mesh, verts, verts_size);

  free(verts);
  
  return (info_err && int_err && double_err && 
          struct_err && tag_delete_err);
}

int entityset_int_tag_test(iMesh_Instance mesh, 
                            iBase_EntitySetHandle *sets, int sets_size,
                            iBase_TagHandle *int_tag) 
{
  int result;
  int dum_val = 11, dum_val2;
  void *dum_val2_ptr = &dum_val2;
  int dum_val2_alloc = sizeof(int), dum_val2_size;

    /* create a tag */
  const char *tag_name = "set_int_tag";
  iMesh_createTag(mesh, tag_name, 1, iBase_INTEGER, 
                  int_tag, &result, 12);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag int_tag in entityset_int_tag_test.\n");
    return FALSE;
  }

    /* put a value in the first set and retrieve */

  iMesh_setEntSetData(mesh, sets[0], *int_tag, 
                      (char*)(&dum_val), sizeof(int), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set int tag (val=11) in entityset_int_tag_test.\n");
    return FALSE;
  }

  dum_val2 = 0;
  iMesh_getEntSetData(mesh, sets[0], *int_tag,
                      &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get int tag (val=11) in entityset_int_tag_test.");
    return FALSE;
  }

  if (dum_val2 != 11) {
    printf("Value of entityset tag (val=11) wrong.\n");
    return FALSE;
  }

    /* put a value in the last faces and retrieve */
  dum_val = 12;
  iMesh_setEntSetData(mesh, sets[sets_size - 1], *int_tag,
                      (char*)(&dum_val), sizeof(int), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set int tag (val=12) in entityset_int_tag_test.");
    return FALSE;
  }

  iMesh_getEntSetData(mesh, sets[sets_size - 1], *int_tag,
                      &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get int tag (val=12) in entityset_int_tag_test.");
    return FALSE;
  }
  
  if (dum_val2 != 12) {
    printf("Value of entityset tag (val=12) wrong.\n");
    return FALSE;
  }

    /* ok, the int tag test worked */
  return TRUE;
}

int entityset_double_tag_test(iMesh_Instance mesh, 
                               iBase_EntitySetHandle *sets, int sets_size,
                               iBase_TagHandle *double_tag) 
{
  int result;
  double dum_val = 1.0e6, dum_val2;
  void *dum_val2_ptr = &dum_val2;
  int dum_val2_alloc = sizeof(double), dum_val2_size;

    /* create a tag */
  const char *tag_name = "set_double_tag";
  iMesh_createTag(mesh, tag_name, 1, iBase_DOUBLE, 
                  double_tag, &result, 15);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag double_tag in entityset_double_tag_test.\n");
    return FALSE;
  }

    /* put a value in the first set and retrieve */

  iMesh_setEntSetData(mesh, sets[0], *double_tag, 
                      (char*)(&dum_val), sizeof(double), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set double tag (val=11) in entityset_double_tag_test.\n");
    return FALSE;
  }

  dum_val2 = 0;
  iMesh_getEntSetData(mesh, sets[0], *double_tag,
                      &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get double tag (val=1.0e6) in entityset_double_tag_test.");
    return FALSE;
  }

  if (dum_val2 != 1.0e6) {
    printf("Value of entityset tag (val=11) wrong.\n");
    return FALSE;
  }

    /* put a value in the last faces and retrieve */
  dum_val = 2.0e9;
  iMesh_setEntSetData(mesh, sets[sets_size-1], *double_tag,
                      (char*)(&dum_val), sizeof(double), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set double tag (val=2.0e9) in entityset_double_tag_test.");
    return FALSE;
  }

  iMesh_getEntSetData(mesh, sets[sets_size-1], *double_tag,
                      &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get double tag (val=2.0e9) in entityset_double_tag_test.");
    return FALSE;
  }
  
  if (dum_val2 != 2.0e9) {
    printf("Value of entityset tag (val=2.0e9) wrong.\n");
    return FALSE;
  }

    /* ok, the double tag test worked */
  return TRUE;
}

int entityset_struct_tag_test(iMesh_Instance mesh, 
                               iBase_EntitySetHandle * /*sets*/, int /*sets_size*/,
                               iBase_TagHandle *struct_tag) 
{
  int result;
  struct TagStruct dum_struct = {3.0e12, 2, 3}, dum_struct2;
  void *dum_struct2_ptr = &dum_struct2;
  int dum_struct_alloc = sizeof(struct TagStruct), dum_struct_size;

    /* create a tag */
  const char *tag_name = "set_struct_tag";
  iMesh_createTag(mesh, tag_name, sizeof(struct TagStruct), iBase_BYTES, 
                  struct_tag, &result, 11);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag struct_tag in entityset_struct_tag_test.\n");
    return FALSE;
  }

    /* put a value in the first vertex and retrieve */

    /* careful setting the value, since tags are opaque */
  iMesh_setEntSetData(mesh, root_set, *struct_tag, 
                      (const char*) &dum_struct, sizeof(struct TagStruct), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set struct tag in entityset_struct_tag_test.\n");
    return FALSE;
  }

  iMesh_getEntSetData(mesh, root_set, *struct_tag,
                      &dum_struct2_ptr, &dum_struct_alloc, &dum_struct_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get struct tag in entityset_struct_tag_test.\n");
    return FALSE;
  }

  if (dum_struct_size != sizeof(struct TagStruct)) {
    printf("Size of entityset struct tag wrong.\n");
    return FALSE;
  }
  if (dum_struct2.test_int1 != dum_struct.test_int1 ||
     dum_struct2.test_int2 != dum_struct.test_int2 ||
     dum_struct2.test_double != dum_struct.test_double) {
    printf("Value of entityset struct tag wrong.\n");
    return FALSE;
  }

    /* ok, the int tag test worked */
  return TRUE;
}

int entityset_tag_delete_test(iMesh_Instance mesh, 
                               iBase_EntitySetHandle *sets, int sets_size) 
{
    /* test forced, unforced deletion of tags from entities */
  int result;
  int delete_err = FALSE;

    /* test getAlliBase_TagHandles for first entity */
  iBase_TagHandle *all_tags = NULL;
  if (sets_size < 1)
  {
    printf("no sets.\n");
    return FALSE;
  }
  iBase_EntitySetHandle dum_entity = sets[0];
  int all_tags_alloc = 0, all_tags_size;
  iMesh_getAllEntSetTags(mesh, sets[0], &all_tags, &all_tags_alloc,
             &all_tags_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't get all tag handles from entityset.\n");
    free(all_tags);
    return FALSE;
  }

  iMesh_rmvEntSetTag(mesh, dum_entity, all_tags[0], &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't remove tag from entityset.\n");
    free(all_tags);
    return FALSE;
  }
  
  iMesh_destroyTag(mesh, all_tags[1], FALSE, &result);
  if (iBase_SUCCESS != result) {
    delete_err = TRUE;
  }
  if (!delete_err) {
    printf("Error when unforced-deleting tag in use on a entityset.\n");
    free(all_tags);
    return FALSE;
  }

  iMesh_destroyTag(mesh, all_tags[1], TRUE, &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't force-delete a tag in use on a entityset.\n");
    free(all_tags);
    return FALSE;
  }

  free(all_tags);
  
    /* ok, we're done */
  return TRUE;
}

int entityset_tag_test(iMesh_Instance mesh)
{
  int result;
  iBase_TagHandle int_tag, double_tag, struct_tag;
  int int_success, double_success, struct_success, tag_delete_success;

    /* get the sets */
  iBase_EntitySetHandle *esets = NULL;
  int esets_alloc = 0, esets_size;
  iMesh_getEntSets(mesh, root_set, 1, &esets, &esets_alloc, &esets_size, &result);
  if (iBase_SUCCESS != result) {
    printf("entitysetGetEntities failed in entityset_tag_test.\n");
    free(esets);
    return FALSE;
  }

     /* entityset int tag */
  int_success = entityset_int_tag_test(mesh, esets, esets_size, 
                                            &int_tag);

    /* entityeset double tag */
  double_success = entityset_double_tag_test(mesh, esets, esets_size, 
                                                  &double_tag);

    /* entityset struct tag */
  struct_success = entityset_struct_tag_test(mesh, esets, esets_size, 
                                                  &struct_tag);

  tag_delete_success = entityset_tag_delete_test(mesh, esets, esets_size);

  free(esets);

  return (int_success && double_success && struct_success
          && tag_delete_success);
}

int mesh_int_tag_test(iMesh_Instance mesh, 
                       iBase_TagHandle *int_tag) 
{
  int result;
  int dum_val = 11, dum_val2;
  void *dum_val2_ptr = &dum_val2;
  int dum_val2_alloc = sizeof(int), dum_val2_size;

    /* create a tag */
  const char *tag_name = "mesh_int_tag";
  iMesh_createTag(mesh, tag_name, 1, iBase_INTEGER, 
                  int_tag, &result, 12);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag int_tag in mesh_int_tag_test.\n");
    return FALSE;
  }

    /* put a value in the first set and retrieve */

  iMesh_setEntSetData(mesh, root_set, *int_tag, 
                      (char*)(&dum_val), sizeof(int), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set int tag (val=11) in mesh_int_tag_test.\n");
    return FALSE;
  }

  dum_val2 = 0;
  iMesh_getEntSetData(mesh, root_set, *int_tag,
                      &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get int tag (val=11) in mesh_int_tag_test.");
    return FALSE;
  }

  if (dum_val2 != 11) {
    printf("Value of entityset tag (val=11) wrong.\n");
    return FALSE;
  }

    /* put a value in the last faces and retrieve */
  dum_val = 12;
  iMesh_setEntSetData(mesh, root_set, *int_tag,
                      (char*)(&dum_val), sizeof(int), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set int tag (val=12) in mesh_int_tag_test.");
    return FALSE;
  }

  iMesh_getEntSetData(mesh, root_set, *int_tag,
                      &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get int tag (val=12) in mesh_int_tag_test.");
    return FALSE;
  }
  
  if (dum_val2 != 12) {
    printf("Value of entityset tag (val=12) wrong.\n");
    return FALSE;
  }

    /* ok, the int tag test worked */
  return TRUE;
}

int mesh_double_tag_test(iMesh_Instance mesh, 
                               iBase_TagHandle *double_tag) 
{
  int result;
  double dum_val = 1.0e6, dum_val2;
  void *dum_val2_ptr = &dum_val2;
  int dum_val2_alloc = sizeof(double), dum_val2_size;

    /* create a tag */
  const char *tag_name = "mesh_double_tag";
  iMesh_createTag(mesh, tag_name, 1, iBase_DOUBLE, 
                  double_tag, &result, 15);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag double_tag in mesh_double_tag_test.\n");
    return FALSE;
  }

    /* put a value in the first set and retrieve */

  iMesh_setEntSetData(mesh, root_set, *double_tag, 
                      (char*)(&dum_val), sizeof(double), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set double tag (val=11) in mesh_double_tag_test.\n");
    return FALSE;
  }

  dum_val2 = 0;
  iMesh_getEntSetData(mesh, root_set, *double_tag,
                      &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get double tag (val=1.0e6) in mesh_double_tag_test.");
    return FALSE;
  }

  if (dum_val2 != 1.0e6) {
    printf("Value of entityset tag (val=11) wrong.\n");
    return FALSE;
  }

    /* put a value in the last faces and retrieve */
  dum_val = 2.0e9;
  iMesh_setEntSetData(mesh, root_set, *double_tag,
                      (char*)(&dum_val), sizeof(double), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set double tag (val=2.0e9) in mesh_double_tag_test.");
    return FALSE;
  }

  iMesh_getEntSetData(mesh, root_set, *double_tag,
                      &dum_val2_ptr, &dum_val2_alloc, &dum_val2_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get double tag (val=2.0e9) in mesh_double_tag_test.");
    return FALSE;
  }
  
  if (dum_val2 != 2.0e9) {
    printf("Value of entityset tag (val=2.0e9) wrong.\n");
    return FALSE;
  }

    /* ok, the double tag test worked */
  return TRUE;
}

int mesh_struct_tag_test(iMesh_Instance mesh, 
                               iBase_TagHandle *struct_tag) 
{
  int result;
  struct TagStruct dum_struct = {3.0e12, 2, 3}, dum_struct2;
  void *dum_struct2_ptr = &dum_struct2;
  int dum_struct_alloc = sizeof(struct TagStruct), dum_struct_size;

    /* create a tag */
  const char *tag_name = "mesh_struct_tag";
  iMesh_createTag(mesh, tag_name, sizeof(struct TagStruct), iBase_BYTES, 
                  struct_tag, &result, 11);
  if (iBase_SUCCESS != result) {
    printf("Failed to create tag struct_tag in vertex_struct_tag_test.\n");
    return FALSE;
  }

    /* put a value in the first vertex and retrieve */

    /* careful setting the value, since tags are opaque */
  iMesh_setEntSetData(mesh, root_set, *struct_tag, 
                      (const char*) &dum_struct, sizeof(struct TagStruct), &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to set struct tag in mesh_struct_tag_test.\n");
    return FALSE;
  }

  iMesh_getEntSetData(mesh, root_set, *struct_tag,
                      &dum_struct2_ptr, &dum_struct_alloc, &dum_struct_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to get struct tag in mesh_struct_tag_test.\n");
    return FALSE;
  }

  if (dum_struct_size != sizeof(struct TagStruct)) {
    printf("Size of entityset struct tag wrong.\n");
    return FALSE;
  }
  if (dum_struct2.test_int1 != dum_struct.test_int1 ||
     dum_struct2.test_int2 != dum_struct.test_int2 ||
     dum_struct2.test_double != dum_struct.test_double) {
    printf("Value of entityset struct tag wrong.\n");
    return FALSE;
  }

    /* ok, the int tag test worked */
  return TRUE;
}

int mesh_tag_delete_test(iMesh_Instance mesh) 
{
    /* test forced, unforced deletion of tags from entities */
  int result;
  int delete_err = FALSE;

    /* test getAlliBase_TagHandles for first entity */
  iBase_TagHandle *all_tags = NULL;
  int all_tags_alloc = 0, all_tags_size;
  iMesh_getAllEntSetTags(mesh, root_set, &all_tags, &all_tags_alloc,
                         &all_tags_size, &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't get all tag handles from entityset.\n");
    return FALSE;
  }

  iMesh_rmvEntSetTag(mesh, root_set, all_tags[0], &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't remove tag from entityset.\n");
    free(all_tags);
    return FALSE;
  }
  
  iMesh_destroyTag(mesh, all_tags[1], FALSE, &result);
  if (iBase_SUCCESS != result) {
    delete_err = TRUE;
  }
  if (!delete_err) {
    printf("Error when unforced-deleting tag in use on a entityset.\n");
    free(all_tags);
    return FALSE;
  }

  iMesh_destroyTag(mesh, all_tags[1], TRUE, &result);
  if (iBase_SUCCESS != result) {
    printf("Couldn't force-delete a tag in use on a entityset.\n");
    free(all_tags);
    return FALSE;
  }

  free(all_tags);
  
    /* ok, we're done */
  return TRUE;
}

int mesh_tag_test(iMesh_Instance mesh)
{
  iBase_TagHandle int_tag, double_tag, struct_tag;
  
    /* entityset int tag */
  int int_success = mesh_int_tag_test(mesh, &int_tag);

    /* entityeset double tag */
  int double_success = mesh_double_tag_test(mesh, &double_tag);

    /* entityset struct tag */
  int struct_success = mesh_struct_tag_test(mesh, &struct_tag);

  int tag_delete_success = mesh_tag_delete_test(mesh);

  return (int_success && double_success && struct_success
          && tag_delete_success);
}

int set_remove_contained_regression( iMesh_Instance mesh )
{
    int err, contained;
    iBase_EntitySetHandle set, sub;

    iMesh_createEntSet(mesh, 0, &set, &err);
    if (iBase_SUCCESS != err)
      return 0;
    iMesh_createEntSet(mesh, 1, &sub, &err);
    if (iBase_SUCCESS != err)
      return 0;

    iMesh_addEntSet(mesh, sub, set, &err);
    if (iBase_SUCCESS != err)
      return 0;

    iMesh_isEntSetContained(mesh, set, sub, &contained, &err);
    if (iBase_SUCCESS != err)
      return 0;
    if (!contained) {
      fprintf(stderr, "isEntSetContained returned false for contained set\n");
      return 0;
    }

    iMesh_rmvEntSet(mesh, sub, set, &err);
    if (iBase_SUCCESS != err)
      return 0;

    iMesh_isEntSetContained(mesh, set, sub, &contained, &err);
    if (iBase_SUCCESS != err)
      return 0;
    if (contained) {
      fprintf(stderr, "isEntSetContained returned true for removed set\n");
      return 0;
    }

    return 1;
}

int all_adjacency_regression( iMesh_Instance mesh )
{
    int err;

    double coords[] = { 0,0,0, 1,1,1 };

    iBase_EntityHandle *verts = NULL;
    int verts_alloc = 0, verts_size;

    iBase_EntityHandle line;
    int status;

    iBase_EntityHandle *adj = NULL;
    int adj_alloc = 0, adj_size;

    iMesh_newMesh("", &mesh, &err, 0);
    if (iBase_SUCCESS != err)
      return 0;

    iMesh_createVtxArr(mesh, 2, iBase_INTERLEAVED, coords, 6, &verts, &verts_alloc,
                       &verts_size, &err);
    if (iBase_SUCCESS != err)
      return 0;

    iMesh_createEnt(mesh, iMesh_LINE_SEGMENT, verts, 2, &line, &status, &err);
    if (iBase_SUCCESS != err || status != iBase_NEW)
      return 0;

    iMesh_getEntAdj(mesh, verts[0], iBase_ALL_TYPES, &adj, &adj_alloc, &adj_size,
                    &err);
    if (iBase_SUCCESS != err)
      return 0;
    if (adj_size != 1 || adj[0] != line) {
        printf("Bad: couldn't find adjacency for vertex\n");
        return 0;
    }
    free(adj);

    adj_alloc = 0; adj = NULL;
    iMesh_getEntAdj(mesh, line, iBase_ALL_TYPES, &adj, &adj_alloc, &adj_size,
                    &err);
    if (iBase_SUCCESS != err)
      return 0;
    if (adj_size != 2 || ((adj[0] != verts[0] || adj[1] != verts[1]) &&
                         (adj[0] != verts[1] || adj[1] != verts[0])) ) {
        printf("Bad: couldn't find adjacencies for line\n");
        free(adj);
        free(verts);
        return 0;
    }
    free(adj);
    free(verts);
    iMesh_dtor(mesh,&err);
    if (iBase_SUCCESS != err)
      return 0;
    return 1;
}

static int ordered_set_regression( iMesh_Instance mesh )
{
  double coords[] = { 0,0,0, 1,1,1 };
  iBase_EntityHandle line, *p, verts[2], ents_in[3], ents_out[3];
  iBase_EntitySetHandle set;
  int i, err, status, two = 2, three = 3;

  iMesh_newMesh("", &mesh, &err, 0);
  CHK(err);
  p = verts;
  iMesh_createVtxArr(mesh, 2, iBase_INTERLEAVED, coords, 6, &p, &two, &two, &err);
  CHK(err);
  iMesh_createEnt(mesh, iMesh_LINE_SEGMENT, verts, 2, &line, &status, &err);
  CHK(err);
  if (status != iBase_NEW)
    return 0;
  iMesh_createEntSet(mesh, 1, &set, &err);
  CHK(err);
  ents_in[0] = verts[1];
  ents_in[1] = line;
  ents_in[2] = verts[0];
  iMesh_addEntArrToSet(mesh, ents_in, three, set, &err);
  CHK(err);
  p = ents_out;
  iMesh_getEntities(mesh, set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, &p, &three, &three, &err);
  CHK(err);
  for (i = 0; i < three; i++) {
    if (ents_in[i] != ents_out[i]) {
      printf("Ordered set does not preserve order\n");
      return 0;
    }
  }
  iMesh_dtor(mesh, &err);
  CHK(err);
  return 1;
}

int array_allocation( iMesh_Instance mesh )
{
  int err;

  double coords[] = { 0,0,0, 1,1,1, 2,2,2, 3,3,3 };

  iBase_EntityHandle *verts = NULL;
  int verts_alloc = 0, verts_size;

  iBase_EntityHandle *ents;
  int ents_alloc, ents_size;

  iMesh_newMesh("", &mesh, &err, 0);
  if (iBase_SUCCESS != err)
    return 0;

  iMesh_getRootSet(mesh, &root_set, &err);
  if (iBase_SUCCESS != err) {
    printf("Failed to return a root set.\n");
    return 0;
  }

  iMesh_createVtxArr(mesh, 4, iBase_INTERLEAVED, coords, 12, &verts, &verts_alloc,
                     &verts_size, &err);
  if (iBase_SUCCESS != err)
    return 0;

  free(verts);

    /* test for proper allocation when array pointer passed in null but alloc'd size not */
  ents_alloc = 3;
  ents = NULL;
  iMesh_getEntities(mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, 
                    &ents, &ents_alloc, &ents_size, &err);
  CHK(err);

  free(ents);

    /* test for proper allocation when array pointer passed in non-null but alloc'd size 0 */
  ents_alloc = 0;
  iMesh_getEntities(mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, 
                    &ents, &ents_alloc, &ents_size, &err);
  CHK(err);

  free(ents);

    /* test for failure when passed in alloc'd size is smaller than it should be */
  ents_alloc -= 1;
  iMesh_getEntities(mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, 
                    &ents, &ents_alloc, &ents_size, &err);
  if (iBase_BAD_ARRAY_SIZE != err && iBase_BAD_ARRAY_DIMENSION != err) {
    err = iBase_FAILURE;
    CHK(err);
  }

  iMesh_dtor(mesh, &err);
  CHK(err);

  return 1;
}

int compare_single_iter( const char* info,
                         iMesh_Instance mesh,
                         iBase_EntitySetHandle set,
                         iBase_EntityHandle* contents,
                         int contents_size,
                         enum iBase_EntityType type,
                         enum iMesh_EntityTopology topo )
{
  iBase_EntityIterator iter = 0;
  int i, twice, has_data, result = iBase_SUCCESS, result2;
  iBase_EntityHandle value;
  
  iMesh_initEntIter( mesh, set, type, topo, 0, &iter, &result );
  if (iBase_SUCCESS != result) {
    printf("%s:%d: Error %d initializing %s iterator for type %d/topo %d\n",
      __FILE__, __LINE__, result, info, (int)type, (int)topo);
    return result;
  }
  
  for (twice = 0; twice < 2; ++twice) {
  
    for (i = 0; i < contents_size; ++i) {
      iMesh_getNextEntIter( mesh, iter, &value, &has_data, &result );
      if (iBase_SUCCESS != result) {
        printf("%s:%d: Error %d stepping %s iterator for type %d/topo %d\n",
          __FILE__, __LINE__, result, info, (int)type, (int)topo);
        goto end_single_iter;
      }

      if (!has_data) {
        printf("%s:%d: %s iterator for type %d/topo %d ended prematurely at %d of %d\n",
          __FILE__, __LINE__, info, (int)type, (int)topo, i, contents_size);
        result = iBase_FAILURE;
        goto end_single_iter;
      }

      if (value != contents[i]) {
        printf("%s:%d: %s iterator for type %d/topo %d returned incorrect value at %d of %d\n",
          __FILE__, __LINE__, info, (int)type, (int)topo, i, contents_size);
        result = iBase_FAILURE;
        goto end_single_iter;
      }
    }

    iMesh_getNextEntIter( mesh, iter, &value, &has_data, &result );
    if (iBase_SUCCESS != result) {
      printf("%s:%d: Error %d stepping %s iterator for type %d/topo %d\n",
        __FILE__, __LINE__, result, info, (int)type, (int)topo);
      goto end_single_iter;
    }

    if (has_data) {
      printf("%s:%d: %s iterator for type %d/topo %d did not end after %d values\n",
        __FILE__, __LINE__, info, (int)type, (int)topo, contents_size);
      result = iBase_FAILURE;
      goto end_single_iter;
    }

    iMesh_resetEntIter( mesh, iter, &result );
    if (iBase_SUCCESS != result) {
      printf("%s:%d: Error %d resetting %s iterator for type %d/topo %d\n",
        __FILE__, __LINE__, result, info, (int)type, (int)topo);
      result = iBase_FAILURE;
      goto end_single_iter;
    }
  }

end_single_iter:
  iMesh_endEntIter( mesh, iter, &result2 );
  if (iBase_SUCCESS != result2) {
    printf("%s:%d: Error %d releasing %s iterator for type %d/topo %d\n",
      __FILE__, __LINE__, result, info, (int)type, (int)topo);
    if (iBase_SUCCESS == result)
      result = result2;
  }
  return result;
}

int compare_array_iter( const char* info,
                        iMesh_Instance mesh,
                        iBase_EntitySetHandle set,
                        iBase_EntityHandle* contents,
                        int contents_size,
                        int array_size,
                        enum iBase_EntityType type,
                        enum iMesh_EntityTopology topo )
{
  iBase_EntityArrIterator iter = 0;
  int i, j, twice, has_data, result = iBase_SUCCESS, result2;
  iBase_EntityHandle* values;
  int values_size, values_alloc = array_size;
  values = (iBase_EntityHandle*)malloc( array_size * sizeof(iBase_EntityHandle) );
  
  iMesh_initEntArrIter( mesh, set, type, topo, array_size, 0, &iter, &result );
  if (iBase_SUCCESS != result) {
    printf("%s:%d: Error %d initializing %s array iterator for type %d/topo %d\n",
      __FILE__, __LINE__, result, info, (int)type, (int)topo);
    free(values);
    return result;
  }
  
  for (twice = 0; twice < 2; ++twice) {
    i = 0;
    while (i < contents_size) {
      
      iMesh_getNextEntArrIter( mesh, iter, &values, &values_alloc, &values_size, &has_data, &result );
      if (iBase_SUCCESS != result) {
        printf("%s:%d: Error %d stepping %s array iterator for type %d/topo %d\n",
          __FILE__, __LINE__, result, info, (int)type, (int)topo);
        goto end_arr_iter;
      }

      if (!has_data || !values_size) {
        printf("%s:%d: %s array iterator for type %d/topo %d ended prematurely at %d of %d\n",
          __FILE__, __LINE__,info, (int)type, (int)topo, i, contents_size);
        result = iBase_FAILURE;
        goto end_arr_iter;
      }
      
      if (i + values_size > contents_size) {
        printf("%s:%d: %s array iterator for type %d/topo %d returned more than %d handles\n",
          __FILE__, __LINE__,info, (int)type, (int)topo, contents_size);
        result = iBase_FAILURE;
        goto end_arr_iter;
      }
      
      if (contents_size - i >= array_size && values_size < array_size) {
        printf("%s:%d: %s array iterator for type %d/topo %d returned fewer than %d handles\n",
          __FILE__, __LINE__, info, (int)type, (int)topo, array_size);
        result = iBase_FAILURE;
        goto end_arr_iter;
      }

      for (j = 0; j < values_size; ++j, ++i) {
        if (values[j] != contents[i]) {
          printf("%s:%d: %s array iterator for type %d/topo %d returned incorrect value at %d of %d\n",
            __FILE__, __LINE__, info, (int)type, (int)topo, i, contents_size);
          result = iBase_FAILURE;
          goto end_arr_iter;
        }
      }
    }

    iMesh_getNextEntArrIter( mesh, iter, &values, &values_alloc, &values_size, &has_data, &result );
    if (iBase_SUCCESS != result) {
      printf("%s:%d: Error %d stepping %s array iterator for type %d/topo %d\n",
        __FILE__, __LINE__, result, info, (int)type, (int)topo);
      goto end_arr_iter;
    }

    if (has_data || values_size) {
      printf("%s:%d: %s array iterator for type %d/topo %d did not end after %d values\n",
        __FILE__, __LINE__, info, (int)type, (int)topo, contents_size);
      result = iBase_FAILURE;
      goto end_arr_iter;
    }

    iMesh_resetEntArrIter( mesh, iter, &result );
    if (iBase_SUCCESS != result) {
      printf("%s:%d: Error %d resetting %s array iterator for type %d/topo %d\n",
        __FILE__, __LINE__, result, info, (int)type, (int)topo);
      result = iBase_FAILURE;
      goto end_arr_iter;
    }
  }

end_arr_iter:
  free(values);
  iMesh_endEntArrIter( mesh, iter, &result2 );
  if (iBase_SUCCESS != result2) {
    printf("%s:%d: Error %d releasing %s array iterator for type %d/topo %d\n",
      __FILE__, __LINE__, result, info, (int)type, (int)topo);
    if (iBase_SUCCESS == result)
      result = result2;
  }
  return result;
}

int test_iterator_common( const char* info,
                          iMesh_Instance mesh,
                          iBase_EntitySetHandle set,
                          int array_size,
                          enum iBase_EntityType type,
                          enum iMesh_EntityTopology topo )
{
  iBase_EntityHandle *contents = NULL;
  int content_size = 0, content_alloc = 0;
  int result;

  iMesh_getEntities( mesh, set, type, topo, &contents, &content_alloc, &content_size, &result );
  CHK(result);
  if (array_size == 1) 
    result = compare_single_iter( info, mesh, set, contents, content_size, type, topo );
  else
    result = compare_array_iter(  info, mesh, set, contents, content_size, array_size, type, topo );
  free(contents);
  return result;
}

int test_iterator( iMesh_Instance mesh )
{
  int result, i;
  iBase_EntitySetHandle root, list, set, *setptr;
  iBase_EntityHandle* array = NULL;
  int array_len = 0, array_size = 0;

  iMesh_getRootSet( mesh, &root, &result );
  CHK(result);

  /* create some sets containing every other handle */
  iMesh_getEntities( mesh, root, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, 
                     &array, &array_size, &array_len, &result );
  CHK(result);
  for (i = 1; i < array_size; i += 2)
    array[i] = array[i - 1];
  for (i = 0; i < 2; ++i) {
    setptr = i ? &list : &set;
    iMesh_createEntSet( mesh, i, setptr, &result );
    if (iBase_SUCCESS != result)
      free(array);
    CHK(result);
    iMesh_addEntArrToSet( mesh, array, array_size, *setptr, &result );
    if (iBase_SUCCESS != result)
      free(array);
    CHK(result);
  }
  free(array);

  /* test single iterator and array iterator for all types */
  for (i = 0; i < iBase_ALL_TYPES; ++i) {
    array_size = 2*i + 2;
    result = test_iterator_common( "root", mesh, root, 1, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
    CHK(result);
    result = test_iterator_common( "root", mesh, root, array_size, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
    CHK(result);
    result = test_iterator_common( "list", mesh, list, 1, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
    CHK(result);
    result = test_iterator_common( "list", mesh, list, array_size, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
    CHK(result);
    result = test_iterator_common( "set", mesh, set, 1, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
    CHK(result);
    result = test_iterator_common( "set", mesh, set, array_size, (enum iBase_EntityType)i, iMesh_ALL_TOPOLOGIES );
    CHK(result);
  }

  /* test single iterator and array iterator for all types */
  for (i = 0; i < iMesh_ALL_TOPOLOGIES; ++i) {
    array_size = 2*i + 2;
    result = test_iterator_common( "root", mesh, root, 1, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
    CHK(result);
    result = test_iterator_common( "root", mesh, root, array_size, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
    CHK(result);
    result = test_iterator_common( "list", mesh, list, 1, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
    CHK(result);
    result = test_iterator_common( "list", mesh, list, array_size, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
    CHK(result);
    result = test_iterator_common( "set", mesh, set, 1, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
    CHK(result);
    result = test_iterator_common( "set", mesh, set, array_size, iBase_ALL_TYPES, (enum iMesh_EntityTopology)i );
    CHK(result);
  }

  return 1;
}

int main( int argc, char *argv[] )
{
    /* Check command line arg */
  const char *filename;
  int number_tests = 0;
  int number_tests_successful = 0;
  int number_tests_not_implemented = 0;
  int number_tests_failed = 0;
  int result;
  iMesh_Instance mesh = NULL;

  if (argc == 2) {
    filename = argv[1];
  }
  else {
    printf("Usage: %s <mesh_filename>\n", argv[0]);
    if (argc != 1)
      return 1;
    printf("  No file specified.  Defaulting to: %s\n", DEFAULT_INPUT_FILE );
    filename = DEFAULT_INPUT_FILE;
  }

    /* initialize the Mesh */
  iMesh_newMesh(NULL, &mesh, &result, 0);
  if (iBase_SUCCESS != result) {
    printf("Failed to create a mesh instance.\n");
    return 1;
  }
  iMesh_getRootSet(mesh, &root_set, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to return a root set.\n");
    return 1;
  }

    /* Print out Header information */
  printf("\n\nTSTT TEST PROGRAM:\n\n");

    /* load_mesh test */
  printf("   load_mesh: ");
  result = load_mesh_test(filename, mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* topology_adjacency_test */
  printf("   topology_adjacency_test: ");
  result = topology_adjacency_test(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* entity connectivity test */
  printf("   entity_connectivity_test: ");
  result = entity_connectivity_test(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");
    
    /* vertex_coordinates_test */
  printf("   vertex_coordinates_test: ");
  result = vertex_coordinates_test(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");
  
    /* topology dimension test */
  printf("   topology_dimension_test: ");
  result = topology_dimension_test(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* entity sets test */
  printf("   entity_sets_test: ");
  result = entity_sets_test(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* vertex tag test */
  printf("   vertex_tag_test: ");
  result = vertex_tag_test(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* entityset tag test */
  printf("   entityset_tag_test: ");
  result = entityset_tag_test(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* mesh tag test */
  printf("   mesh_tag_test: ");
  result = mesh_tag_test(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* iterator test */
  printf("   test_iterator: ");
  result = test_iterator(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* regression test for remove/contained bug */
  printf("   set_remove_contained_regression: ");
  result = set_remove_contained_regression(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* regression test for adjacencies with iBase_ALL_TYPES bug */
  printf("   all_adjacency_regression: ");
  result = all_adjacency_regression(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* test for error codes */
  printf("   error_code_test: ");
  result = error_code_test(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

      /* regression test for ordered sets not preserving order */
  printf("   ordered_set_regression: ");
  result = ordered_set_regression(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* test for array allocation behavior */
  printf("   array_allocation_regression: ");
  result = array_allocation(mesh);
  handle_error_code(result, &number_tests_failed,
                    &number_tests_not_implemented,
                    &number_tests_successful);
  number_tests++;
  printf("\n");

    /* summary */

  printf("\nTSTT TEST SUMMARY: \n");
                                                                                                                                
  printf("   Number Tests:           %d\n", number_tests);
  printf("   Number Successful:      %d\n", number_tests_successful);
  printf("   Number Not Implemented: %d\n", number_tests_not_implemented);
  printf("   Number Failed:          %d\n", number_tests_failed);
  printf("\n\n\n");

    /* delete the mesh */
  iMesh_dtor(mesh, &result);
  if (iBase_SUCCESS != result) {
    printf("Failed to destruct the mesh instance.\n");
    return 1;
  }
  
  return number_tests_failed;
}