MitkCoreTestDriver_main.cpp

Go to the documentation of this file.

#include <ctype.h>  /* NOLINT */
#include <stdio.h>  /* NOLINT */
#include <stdlib.h> /* NOLINT */
#include <string.h> /* NOLINT */

#if defined(_MSC_VER)
#pragma warning(disable : 4996) /* deprecation */
#endif

#include "/home/ubuntu/dcl1/Build-D-n/MITK-build/Modules/Core/test/MitkCoreTestDriver_extras.h"


/* Forward declare test functions. */
int mitkAccessByItkTest(int, char*[]);
int mitkCoreObjectFactoryTest(int, char*[]);
int mitkDataNodeTest(int, char*[]);
int mitkMaterialTest(int, char*[]);
int mitkActionTest(int, char*[]);
int mitkDispatcherTest(int, char*[]);
int mitkEnumerationPropertyTest(int, char*[]);
int mitkFileReaderRegistryTest(int, char*[]);
int mitkFloatToStringTest(int, char*[]);
int mitkGenericPropertyTest(int, char*[]);
int mitkGeometry3DTest(int, char*[]);
int mitkGeometry3DEqualTest(int, char*[]);
int mitkGeometryDataIOTest(int, char*[]);
int mitkGeometryDataToSurfaceFilterTest(int, char*[]);
int mitkImageCastTest(int, char*[]);
int mitkImageDataItemTest(int, char*[]);
int mitkImageGeneratorTest(int, char*[]);
int mitkIOUtilTest(int, char*[]);
int mitkBaseDataTest(int, char*[]);
int mitkImportItkImageTest(int, char*[]);
int mitkGrabItkImageMemoryTest(int, char*[]);
int mitkInstantiateAccessFunctionTest(int, char*[]);
int mitkLevelWindowTest(int, char*[]);
int mitkMessageTest(int, char*[]);
int mitkPixelTypeTest(int, char*[]);
int mitkPlaneGeometryTest(int, char*[]);
int mitkPointSetTest(int, char*[]);
int mitkPointSetEqualTest(int, char*[]);
int mitkPointSetFileIOTest(int, char*[]);
int mitkPointSetOnEmptyTest(int, char*[]);
int mitkPointSetLocaleTest(int, char*[]);
int mitkPointSetWriterTest(int, char*[]);
int mitkPointSetPointOperationsTest(int, char*[]);
int mitkProgressBarTest(int, char*[]);
int mitkPropertyTest(int, char*[]);
int mitkPropertyListTest(int, char*[]);
int mitkPropertyPersistenceTest(int, char*[]);
int mitkPropertyPersistenceInfoTest(int, char*[]);
int mitkPropertyRelationRuleBaseTest(int, char*[]);
int mitkPropertyRelationsTest(int, char*[]);
int mitkSlicedGeometry3DTest(int, char*[]);
int mitkSliceNavigationControllerTest(int, char*[]);
int mitkSurfaceTest(int, char*[]);
int mitkSurfaceEqualTest(int, char*[]);
int mitkSurfaceToSurfaceFilterTest(int, char*[]);
int mitkTimeGeometryTest(int, char*[]);
int mitkProportionalTimeGeometryTest(int, char*[]);
int mitkUndoControllerTest(int, char*[]);
int mitkVtkWidgetRenderingTest(int, char*[]);
int mitkVerboseLimitedLinearUndoTest(int, char*[]);
int mitkWeakPointerTest(int, char*[]);
int mitkTransferFunctionTest(int, char*[]);
int mitkStepperTest(int, char*[]);
int mitkRenderingManagerTest(int, char*[]);
int mitkCompositePixelValueToStringTest(int, char*[]);
int vtkMitkThickSlicesFilterTest(int, char*[]);
int mitkNodePredicateSourceTest(int, char*[]);
int mitkNodePredicateDataPropertyTest(int, char*[]);
int mitkNodePredicateFunctionTest(int, char*[]);
int mitkVectorTest(int, char*[]);
int mitkClippedSurfaceBoundsCalculatorTest(int, char*[]);
int mitkExceptionTest(int, char*[]);
int mitkExtractSliceFilterTest(int, char*[]);
int mitkLogTest(int, char*[]);
int mitkImageDimensionConverterTest(int, char*[]);
int mitkLoggingAdapterTest(int, char*[]);
int mitkUIDGeneratorTest(int, char*[]);
int mitkPlanePositionManagerTest(int, char*[]);
int mitkAffineTransformBaseTest(int, char*[]);
int mitkPropertyAliasesTest(int, char*[]);
int mitkPropertyDescriptionsTest(int, char*[]);
int mitkPropertyExtensionsTest(int, char*[]);
int mitkPropertyFiltersTest(int, char*[]);
int mitkPropertyKeyPathTest(int, char*[]);
int mitkTinyXMLTest(int, char*[]);
int mitkRawImageFileReaderTest(int, char*[]);
int mitkInteractionEventTest(int, char*[]);
int mitkLookupTableTest(int, char*[]);
int mitkSTLFileReaderTest(int, char*[]);
int mitkPointTypeConversionTest(int, char*[]);
int mitkVectorTypeConversionTest(int, char*[]);
int mitkMatrixTypeConversionTest(int, char*[]);
int mitkArrayTypeConversionTest(int, char*[]);
int mitkSurfaceToImageFilterTest(int, char*[]);
int mitkBaseGeometryTest(int, char*[]);
int mitkImageToSurfaceFilterTest(int, char*[]);
int mitkEqualTest(int, char*[]);
int mitkLineTest(int, char*[]);
int mitkArbitraryTimeGeometryTest(int, char*[]);
int mitkItkImageIOTest(int, char*[]);
int mitkLevelWindowManagerCppUnitTest(int, char*[]);
int mitkVectorPropertyTest(int, char*[]);
int mitkTemporoSpatialStringPropertyTest(int, char*[]);
int mitkPropertyNameHelperTest(int, char*[]);
int mitkNodePredicateGeometryTest(int, char*[]);
int mitkPreferenceListReaderOptionsFunctorTest(int, char*[]);
int mitkGenericIDRelationRuleTest(int, char*[]);
int mitkSourceImageRelationRuleTest(int, char*[]);
int mitkPointSetDataInteractorTest(int, char*[]);
int mitkSurfaceVtkMapper2DTest(int, char*[]);
int mitkSurfaceVtkMapper2D3DTest(int, char*[]);
int mitkImageTimeSelectorTest(int, char*[]);
int mitkImageAccessorTest(int, char*[]);
int mitkSurfaceVtkWriterTest(int, char*[]);
int mitkDataStorageTest(int, char*[]);
int mitkDataNodeTest(int, char*[]);
int mitkEventConfigTest(int, char*[]);
int mitkPointSetLocaleTest(int, char*[]);
int mitkImageTest(int, char*[]);
int mitkImageVtkMapper2DTest(int, char*[]);
int mitkImageVtkMapper2DLevelWindowTest(int, char*[]);
int mitkImageVtkMapper2DOpacityTest(int, char*[]);
int mitkImageVtkMapper2DResliceInterpolationPropertyTest(int, char*[]);
int mitkImageVtkMapper2DColorTest(int, char*[]);
int mitkImageVtkMapper2DSwivelTest(int, char*[]);
int mitkImageVtkMapper2DTransferFunctionTest(int, char*[]);
int mitkImageVtkMapper2DOpacityTransferFunctionTest(int, char*[]);
int mitkImageVtkMapper2DLookupTableTest(int, char*[]);
int mitkSurfaceVtkMapper3DTest(int, char*[]);
int mitkVolumeCalculatorTest(int, char*[]);
int mitkLevelWindowManagerTest(int, char*[]);
int mitkPointSetVtkMapper2DTest(int, char*[]);
int mitkPointSetVtkMapper2DImageTest(int, char*[]);
int mitkPointSetVtkMapper2DGlyphTypeTest(int, char*[]);
int mitkPointSetVtkMapper2DTransformedPointsTest(int, char*[]);
int mitkVTKRenderWindowSizeTest(int, char*[]);
int mitkMultiComponentImageDataComparisonFilterTest(int, char*[]);
int mitkImageToItkTest(int, char*[]);
int mitkImageSliceSelectorTest(int, char*[]);
int mitkPointSetReaderTest(int, char*[]);
int mitkImageEqualTest(int, char*[]);
int mitkRotatedSlice4DTest(int, char*[]);
int mitkPlaneGeometryDataMapper2DTest(int, char*[]);
int mitkSurfaceDepthSortingTest(int, char*[]);


#ifdef __cplusplus
#define CM_CAST(TYPE, EXPR) static_cast<TYPE>(EXPR)
#else
#define CM_CAST(TYPE, EXPR) (TYPE)(EXPR)
#endif

/* Create map.  */

typedef int (*MainFuncPointer)(int, char* []); /* NOLINT */
typedef struct /* NOLINT */
{
  const char* name;
  MainFuncPointer func;
} functionMapEntry;

static functionMapEntry cmakeGeneratedFunctionMapEntries[] = {
    {
    "mitkAccessByItkTest",
    mitkAccessByItkTest
  },
  {
    "mitkCoreObjectFactoryTest",
    mitkCoreObjectFactoryTest
  },
  {
    "mitkDataNodeTest",
    mitkDataNodeTest
  },
  {
    "mitkMaterialTest",
    mitkMaterialTest
  },
  {
    "mitkActionTest",
    mitkActionTest
  },
  {
    "mitkDispatcherTest",
    mitkDispatcherTest
  },
  {
    "mitkEnumerationPropertyTest",
    mitkEnumerationPropertyTest
  },
  {
    "mitkFileReaderRegistryTest",
    mitkFileReaderRegistryTest
  },
  {
    "mitkFloatToStringTest",
    mitkFloatToStringTest
  },
  {
    "mitkGenericPropertyTest",
    mitkGenericPropertyTest
  },
  {
    "mitkGeometry3DTest",
    mitkGeometry3DTest
  },
  {
    "mitkGeometry3DEqualTest",
    mitkGeometry3DEqualTest
  },
  {
    "mitkGeometryDataIOTest",
    mitkGeometryDataIOTest
  },
  {
    "mitkGeometryDataToSurfaceFilterTest",
    mitkGeometryDataToSurfaceFilterTest
  },
  {
    "mitkImageCastTest",
    mitkImageCastTest
  },
  {
    "mitkImageDataItemTest",
    mitkImageDataItemTest
  },
  {
    "mitkImageGeneratorTest",
    mitkImageGeneratorTest
  },
  {
    "mitkIOUtilTest",
    mitkIOUtilTest
  },
  {
    "mitkBaseDataTest",
    mitkBaseDataTest
  },
  {
    "mitkImportItkImageTest",
    mitkImportItkImageTest
  },
  {
    "mitkGrabItkImageMemoryTest",
    mitkGrabItkImageMemoryTest
  },
  {
    "mitkInstantiateAccessFunctionTest",
    mitkInstantiateAccessFunctionTest
  },
  {
    "mitkLevelWindowTest",
    mitkLevelWindowTest
  },
  {
    "mitkMessageTest",
    mitkMessageTest
  },
  {
    "mitkPixelTypeTest",
    mitkPixelTypeTest
  },
  {
    "mitkPlaneGeometryTest",
    mitkPlaneGeometryTest
  },
  {
    "mitkPointSetTest",
    mitkPointSetTest
  },
  {
    "mitkPointSetEqualTest",
    mitkPointSetEqualTest
  },
  {
    "mitkPointSetFileIOTest",
    mitkPointSetFileIOTest
  },
  {
    "mitkPointSetOnEmptyTest",
    mitkPointSetOnEmptyTest
  },
  {
    "mitkPointSetLocaleTest",
    mitkPointSetLocaleTest
  },
  {
    "mitkPointSetWriterTest",
    mitkPointSetWriterTest
  },
  {
    "mitkPointSetPointOperationsTest",
    mitkPointSetPointOperationsTest
  },
  {
    "mitkProgressBarTest",
    mitkProgressBarTest
  },
  {
    "mitkPropertyTest",
    mitkPropertyTest
  },
  {
    "mitkPropertyListTest",
    mitkPropertyListTest
  },
  {
    "mitkPropertyPersistenceTest",
    mitkPropertyPersistenceTest
  },
  {
    "mitkPropertyPersistenceInfoTest",
    mitkPropertyPersistenceInfoTest
  },
  {
    "mitkPropertyRelationRuleBaseTest",
    mitkPropertyRelationRuleBaseTest
  },
  {
    "mitkPropertyRelationsTest",
    mitkPropertyRelationsTest
  },
  {
    "mitkSlicedGeometry3DTest",
    mitkSlicedGeometry3DTest
  },
  {
    "mitkSliceNavigationControllerTest",
    mitkSliceNavigationControllerTest
  },
  {
    "mitkSurfaceTest",
    mitkSurfaceTest
  },
  {
    "mitkSurfaceEqualTest",
    mitkSurfaceEqualTest
  },
  {
    "mitkSurfaceToSurfaceFilterTest",
    mitkSurfaceToSurfaceFilterTest
  },
  {
    "mitkTimeGeometryTest",
    mitkTimeGeometryTest
  },
  {
    "mitkProportionalTimeGeometryTest",
    mitkProportionalTimeGeometryTest
  },
  {
    "mitkUndoControllerTest",
    mitkUndoControllerTest
  },
  {
    "mitkVtkWidgetRenderingTest",
    mitkVtkWidgetRenderingTest
  },
  {
    "mitkVerboseLimitedLinearUndoTest",
    mitkVerboseLimitedLinearUndoTest
  },
  {
    "mitkWeakPointerTest",
    mitkWeakPointerTest
  },
  {
    "mitkTransferFunctionTest",
    mitkTransferFunctionTest
  },
  {
    "mitkStepperTest",
    mitkStepperTest
  },
  {
    "mitkRenderingManagerTest",
    mitkRenderingManagerTest
  },
  {
    "mitkCompositePixelValueToStringTest",
    mitkCompositePixelValueToStringTest
  },
  {
    "vtkMitkThickSlicesFilterTest",
    vtkMitkThickSlicesFilterTest
  },
  {
    "mitkNodePredicateSourceTest",
    mitkNodePredicateSourceTest
  },
  {
    "mitkNodePredicateDataPropertyTest",
    mitkNodePredicateDataPropertyTest
  },
  {
    "mitkNodePredicateFunctionTest",
    mitkNodePredicateFunctionTest
  },
  {
    "mitkVectorTest",
    mitkVectorTest
  },
  {
    "mitkClippedSurfaceBoundsCalculatorTest",
    mitkClippedSurfaceBoundsCalculatorTest
  },
  {
    "mitkExceptionTest",
    mitkExceptionTest
  },
  {
    "mitkExtractSliceFilterTest",
    mitkExtractSliceFilterTest
  },
  {
    "mitkLogTest",
    mitkLogTest
  },
  {
    "mitkImageDimensionConverterTest",
    mitkImageDimensionConverterTest
  },
  {
    "mitkLoggingAdapterTest",
    mitkLoggingAdapterTest
  },
  {
    "mitkUIDGeneratorTest",
    mitkUIDGeneratorTest
  },
  {
    "mitkPlanePositionManagerTest",
    mitkPlanePositionManagerTest
  },
  {
    "mitkAffineTransformBaseTest",
    mitkAffineTransformBaseTest
  },
  {
    "mitkPropertyAliasesTest",
    mitkPropertyAliasesTest
  },
  {
    "mitkPropertyDescriptionsTest",
    mitkPropertyDescriptionsTest
  },
  {
    "mitkPropertyExtensionsTest",
    mitkPropertyExtensionsTest
  },
  {
    "mitkPropertyFiltersTest",
    mitkPropertyFiltersTest
  },
  {
    "mitkPropertyKeyPathTest",
    mitkPropertyKeyPathTest
  },
  {
    "mitkTinyXMLTest",
    mitkTinyXMLTest
  },
  {
    "mitkRawImageFileReaderTest",
    mitkRawImageFileReaderTest
  },
  {
    "mitkInteractionEventTest",
    mitkInteractionEventTest
  },
  {
    "mitkLookupTableTest",
    mitkLookupTableTest
  },
  {
    "mitkSTLFileReaderTest",
    mitkSTLFileReaderTest
  },
  {
    "mitkPointTypeConversionTest",
    mitkPointTypeConversionTest
  },
  {
    "mitkVectorTypeConversionTest",
    mitkVectorTypeConversionTest
  },
  {
    "mitkMatrixTypeConversionTest",
    mitkMatrixTypeConversionTest
  },
  {
    "mitkArrayTypeConversionTest",
    mitkArrayTypeConversionTest
  },
  {
    "mitkSurfaceToImageFilterTest",
    mitkSurfaceToImageFilterTest
  },
  {
    "mitkBaseGeometryTest",
    mitkBaseGeometryTest
  },
  {
    "mitkImageToSurfaceFilterTest",
    mitkImageToSurfaceFilterTest
  },
  {
    "mitkEqualTest",
    mitkEqualTest
  },
  {
    "mitkLineTest",
    mitkLineTest
  },
  {
    "mitkArbitraryTimeGeometryTest",
    mitkArbitraryTimeGeometryTest
  },
  {
    "mitkItkImageIOTest",
    mitkItkImageIOTest
  },
  {
    "mitkLevelWindowManagerCppUnitTest",
    mitkLevelWindowManagerCppUnitTest
  },
  {
    "mitkVectorPropertyTest",
    mitkVectorPropertyTest
  },
  {
    "mitkTemporoSpatialStringPropertyTest",
    mitkTemporoSpatialStringPropertyTest
  },
  {
    "mitkPropertyNameHelperTest",
    mitkPropertyNameHelperTest
  },
  {
    "mitkNodePredicateGeometryTest",
    mitkNodePredicateGeometryTest
  },
  {
    "mitkPreferenceListReaderOptionsFunctorTest",
    mitkPreferenceListReaderOptionsFunctorTest
  },
  {
    "mitkGenericIDRelationRuleTest",
    mitkGenericIDRelationRuleTest
  },
  {
    "mitkSourceImageRelationRuleTest",
    mitkSourceImageRelationRuleTest
  },
  {
    "mitkPointSetDataInteractorTest",
    mitkPointSetDataInteractorTest
  },
  {
    "mitkSurfaceVtkMapper2DTest",
    mitkSurfaceVtkMapper2DTest
  },
  {
    "mitkSurfaceVtkMapper2D3DTest",
    mitkSurfaceVtkMapper2D3DTest
  },
  {
    "mitkImageTimeSelectorTest",
    mitkImageTimeSelectorTest
  },
  {
    "mitkImageAccessorTest",
    mitkImageAccessorTest
  },
  {
    "mitkSurfaceVtkWriterTest",
    mitkSurfaceVtkWriterTest
  },
  {
    "mitkDataStorageTest",
    mitkDataStorageTest
  },
  {
    "mitkDataNodeTest",
    mitkDataNodeTest
  },
  {
    "mitkEventConfigTest",
    mitkEventConfigTest
  },
  {
    "mitkPointSetLocaleTest",
    mitkPointSetLocaleTest
  },
  {
    "mitkImageTest",
    mitkImageTest
  },
  {
    "mitkImageVtkMapper2DTest",
    mitkImageVtkMapper2DTest
  },
  {
    "mitkImageVtkMapper2DLevelWindowTest",
    mitkImageVtkMapper2DLevelWindowTest
  },
  {
    "mitkImageVtkMapper2DOpacityTest",
    mitkImageVtkMapper2DOpacityTest
  },
  {
    "mitkImageVtkMapper2DResliceInterpolationPropertyTest",
    mitkImageVtkMapper2DResliceInterpolationPropertyTest
  },
  {
    "mitkImageVtkMapper2DColorTest",
    mitkImageVtkMapper2DColorTest
  },
  {
    "mitkImageVtkMapper2DSwivelTest",
    mitkImageVtkMapper2DSwivelTest
  },
  {
    "mitkImageVtkMapper2DTransferFunctionTest",
    mitkImageVtkMapper2DTransferFunctionTest
  },
  {
    "mitkImageVtkMapper2DOpacityTransferFunctionTest",
    mitkImageVtkMapper2DOpacityTransferFunctionTest
  },
  {
    "mitkImageVtkMapper2DLookupTableTest",
    mitkImageVtkMapper2DLookupTableTest
  },
  {
    "mitkSurfaceVtkMapper3DTest",
    mitkSurfaceVtkMapper3DTest
  },
  {
    "mitkVolumeCalculatorTest",
    mitkVolumeCalculatorTest
  },
  {
    "mitkLevelWindowManagerTest",
    mitkLevelWindowManagerTest
  },
  {
    "mitkPointSetVtkMapper2DTest",
    mitkPointSetVtkMapper2DTest
  },
  {
    "mitkPointSetVtkMapper2DImageTest",
    mitkPointSetVtkMapper2DImageTest
  },
  {
    "mitkPointSetVtkMapper2DGlyphTypeTest",
    mitkPointSetVtkMapper2DGlyphTypeTest
  },
  {
    "mitkPointSetVtkMapper2DTransformedPointsTest",
    mitkPointSetVtkMapper2DTransformedPointsTest
  },
  {
    "mitkVTKRenderWindowSizeTest",
    mitkVTKRenderWindowSizeTest
  },
  {
    "mitkMultiComponentImageDataComparisonFilterTest",
    mitkMultiComponentImageDataComparisonFilterTest
  },
  {
    "mitkImageToItkTest",
    mitkImageToItkTest
  },
  {
    "mitkImageSliceSelectorTest",
    mitkImageSliceSelectorTest
  },
  {
    "mitkPointSetReaderTest",
    mitkPointSetReaderTest
  },
  {
    "mitkImageEqualTest",
    mitkImageEqualTest
  },
  {
    "mitkRotatedSlice4DTest",
    mitkRotatedSlice4DTest
  },
  {
    "mitkPlaneGeometryDataMapper2DTest",
    mitkPlaneGeometryDataMapper2DTest
  },
  {
    "mitkSurfaceDepthSortingTest",
    mitkSurfaceDepthSortingTest
  },

  { NULL, NULL } /* NOLINT */
};

static const int NumTests = CM_CAST(int,
  sizeof(cmakeGeneratedFunctionMapEntries) / sizeof(functionMapEntry)) - 1;

/* Allocate and create a lowercased copy of string
   (note that it has to be free'd manually) */
static char* lowercase(const char* string)
{
  char *new_string, *p;
  size_t stringSize;

  stringSize = CM_CAST(size_t, strlen(string) + 1);
  new_string = CM_CAST(char*, malloc(sizeof(char) * stringSize));

  if (new_string == NULL) { /* NOLINT */
    return NULL;            /* NOLINT */
  }
  strcpy(new_string, string);
  for (p = new_string; *p != 0; ++p) {
    *p = CM_CAST(char, tolower(*p));
  }
  return new_string;
}

int main(int ac, char* av[])
{
  int i, testNum = 0, partial_match;
  char *arg;
  int testToRun = -1;

  

  /* If no test name was given */
  /* process command line with user function.  */
  if (ac < 2) {
    /* Ask for a test.  */
    printf("Available tests:\n");
    for (i = 0; i < NumTests; ++i) {
      printf("%3d. %s\n", i, cmakeGeneratedFunctionMapEntries[i].name);
    }
    printf("To run a test, enter the test number: ");
    fflush(stdout);
    if (scanf("%d", &testNum) != 1) {
      printf("Couldn't parse that input as a number\n");
      return -1;
    }
    if (testNum >= NumTests) {
      printf("%3d is an invalid test number.\n", testNum);
      return -1;
    }
    testToRun = testNum;
    ac--;
    av++;
  }
  partial_match = 0;
  arg = NULL; /* NOLINT */
  /* If partial match is requested.  */
  if (testToRun == -1 && ac > 1) {
    partial_match = (strcmp(av[1], "-R") == 0) ? 1 : 0;
  }
  if (partial_match != 0 && ac < 3) {
    printf("-R needs an additional parameter.\n");
    return -1;
  }
  if (testToRun == -1) {
    arg = lowercase(av[1 + partial_match]);
  }
  for (i = 0; i < NumTests && testToRun == -1; ++i) {
    char *test_name = lowercase(cmakeGeneratedFunctionMapEntries[i].name);
    if (partial_match != 0 && strstr(test_name, arg) != NULL) { /* NOLINT */
      testToRun = i;
      ac -= 2;
      av += 2;
    } else if (partial_match == 0 && strcmp(test_name, arg) == 0) {
      testToRun = i;
      ac--;
      av++;
    }
    free(test_name);
  }
  free(arg);
  if (testToRun != -1) {
    int result;

for (int avIndex = 1; avIndex < ac; ++avIndex) globalCmdLineArgs.push_back(av[avIndex]);
mitk::LoggingBackend::Register();
;
    if (testToRun < 0 || testToRun >= NumTests) {
      printf("testToRun was modified by TestDriver code to an invalid value: "
             "%3d.\n",
             testNum);
      return -1;
    }
    result = (*cmakeGeneratedFunctionMapEntries[testToRun].func)(ac, av);
mitk::LoggingBackend::Unregister();
    return result;
  }

  /* Nothing was run, display the test names.  */
  printf("Available tests:\n");
  for (i = 0; i < NumTests; ++i) {
    printf("%3d. %s\n", i, cmakeGeneratedFunctionMapEntries[i].name);
  }
  printf("Failed: %s is an invalid test name.\n", av[1]);

  return -1;
}