int UnitTest::
test(bool rethrow_exceptions)
{
try {
Timer(); // Init performance counting
TaskTimer tt("Running tests");
RUNTEST(Tfr::FreqAxis);
RUNTEST(Tfr::StftDesc);
RUNTEST(Tfr::DummyTransform);
RUNTEST(Tfr::DummyTransformDesc);
RUNTEST(Tfr::TransformOperationDesc);
} catch (const ExceptionAssert& x) {
if (rethrow_exceptions)
throw;
char const * const * f = boost::get_error_info<boost::throw_file>(x);
int const * l = boost::get_error_info<boost::throw_line>(x);
char const * const * c = boost::get_error_info<ExceptionAssert::ExceptionAssert_condition>(x);
std::string const * m = boost::get_error_info<ExceptionAssert::ExceptionAssert_message>(x);
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s:%d: %s. %s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% (f?*f:0) % (l?*l:-1) % (c?*c:0) % (m?*m:0) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (const exception& x) {
if (rethrow_exceptions)
throw;
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% vartype(x) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (...) {
if (rethrow_exceptions)
throw;
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("Not an std::exception\n"
"%s\n"
" FAILED in %s::test()\n\n")
% boost::current_exception_diagnostic_information () % lastname ).c_str());
fflush(stderr);
return 1;
}
printf("\n OK\n\n");
return 0;
}
int main()
{
RUNTEST(class_test);
RUNTEST(decorrelation_test);
RUNTEST(parallel_test);
RUNTEST(max_jump_test);
RUNTEST(deterministic_test);
return 0;
}
int main() {
// Low-level tests
RUNTEST(test_set_bitmap);
// High-level tests
RUNTEST(test_init_handles_errors);
RUNTEST(test_open_handles_errors);
RUNTEST(test_init_writes_blocks);
RUNTEST(test_init_works);
RUNTEST(test_allocate_blocks);
RUNTEST(test_directories);
RUNTEST(test_write_files);
RUNTEST(test_read_files);
printf("All tests pass. Yay!\n");
return 0;
}
int main(int argc, char *argv[])
{
RUNTEST(udp, nbr_sock_test(3, 1000, 10, 256000, "UDP"), -1);
RUNTEST(tcp, nbr_sock_test(2, 1, 10, 256000, "TCP"), -2);
if (argv[2]) {
RUNTEST(plugin, nbr_sock_test(3, 1000, 60, 128000, argv[2]), -100);
}
if (nbr_init(NULL) != NBR_OK) {
return -3;
}
RUNTEST(thread, nbr_thread_test(), -4);
RUNTEST(str, nbr_str_test(), -5);
RUNTEST(array, nbr_array_test(), -6);
RUNTEST(search, nbr_search_test(), -7);
nbr_fin();
return 0;
}
/*
* These tests the key generation functions, using the test cases provided in
* http://tools.ietf.org/html/rfc6070
*/
int main(int argc, char **argv) {
RUNTEST(argv[0],test_encrypt_decrypt);
return 0;
}
int UnitTest::
test(bool rethrow_exceptions)
{
try {
Timer(); // Init performance counting
TaskTimer tt("Running tests");
RUNTEST(DataStorageString);
RUNTEST(Factor);
RUNTEST(GeometricAlgebra);
RUNTEST(GlFrameBuffer);
RUNTEST(glinfo);
RUNTEST(glProjection);
#ifdef LEGACY_OPENGL
RUNTEST(GlSyncObjectMutex);
#endif
RUNTEST(GlTextureRead);
RUNTEST(neat_math);
RUNTEST(ResampleTexture);
RUNTEST(Float16Compressor);
} catch (const ExceptionAssert& x) {
if (rethrow_exceptions)
throw;
char const * const * f = boost::get_error_info<boost::throw_file>(x);
int const * l = boost::get_error_info<boost::throw_line>(x);
char const * const * c = boost::get_error_info<ExceptionAssert::ExceptionAssert_condition>(x);
std::string const * m = boost::get_error_info<ExceptionAssert::ExceptionAssert_message>(x);
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s:%d: %s. %s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% (f?*f:0) % (l?*l:-1) % (c?*c:0) % (m?*m:0) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (const exception& x) {
if (rethrow_exceptions)
throw;
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% vartype(x) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (...) {
if (rethrow_exceptions)
throw;
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("Not an std::exception\n"
"%s\n"
" FAILED in %s::test()\n\n")
% boost::current_exception_diagnostic_information () % lastname ).c_str());
fflush(stderr);
return 1;
}
printf("\n OK\n\n");
return 0;
}
int UnitTest::
test(bool rethrow_exceptions)
{
try {
Timer(); // Init performance counting
TaskTimer tt("Running tests");
RUNTEST(Heightmap::TfrMapping);
RUNTEST(Heightmap::Update::UpdateProducer);
RUNTEST(Heightmap::Update::UpdateProducerDesc);
RUNTEST(Heightmap::TfrMappings::StftBlockFilter);
RUNTEST(Heightmap::TfrMappings::StftBlockFilterDesc);
RUNTEST(Heightmap::TfrMappings::CwtBlockFilter);
RUNTEST(Heightmap::TfrMappings::CwtBlockFilterDesc);
RUNTEST(Heightmap::TfrMappings::WaveformBlockFilter);
RUNTEST(Heightmap::TfrMappings::WaveformBlockFilterDesc);
RUNTEST(Heightmap::TfrMappings::CepstrumBlockFilter);
RUNTEST(Heightmap::TfrMappings::CepstrumBlockFilterDesc);
} catch (const ExceptionAssert& x) {
if (rethrow_exceptions)
throw;
char const * const * f = boost::get_error_info<boost::throw_file>(x);
int const * l = boost::get_error_info<boost::throw_line>(x);
char const * const * c = boost::get_error_info<ExceptionAssert::ExceptionAssert_condition>(x);
std::string const * m = boost::get_error_info<ExceptionAssert::ExceptionAssert_message>(x);
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s:%d: %s. %s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% (f?*f:0) % (l?*l:-1) % (c?*c:0) % (m?*m:0) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (const exception& x) {
if (rethrow_exceptions)
throw;
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% vartype(x) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (...) {
if (rethrow_exceptions)
throw;
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("Not an std::exception\n"
"%s\n"
" FAILED in %s::test()\n\n")
% boost::current_exception_diagnostic_information () % lastname ).c_str());
fflush(stderr);
return 1;
}
printf("\n OK\n\n");
return 0;
}
int UnitTest::
test(bool rethrow_exceptions)
{
try {
Timer(); // Init performance counting
TaskTimer tt("Running tests");
RUNTEST(Backtrace);
RUNTEST(ExceptionAssert);
RUNTEST(PrettifySegfault);
RUNTEST(Timer);
RUNTEST(shared_state_test);
RUNTEST(VerifyExecutionTime);
RUNTEST(spinning_barrier);
RUNTEST(locking_barrier);
RUNTEST(shared_state_traits_backtrace);
} catch (const ExceptionAssert& x) {
if (rethrow_exceptions)
throw;
char const * const * f = boost::get_error_info<boost::throw_file>(x);
int const * l = boost::get_error_info<boost::throw_line>(x);
char const * const * c = boost::get_error_info<ExceptionAssert::ExceptionAssert_condition>(x);
std::string const * m = boost::get_error_info<ExceptionAssert::ExceptionAssert_message>(x);
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s:%d: %s. %s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% (f?*f:0) % (l?*l:-1) % (c?*c:0) % (m?*m:0) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (const exception& x) {
if (rethrow_exceptions)
throw;
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% vartype(x) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (...) {
if (rethrow_exceptions)
throw;
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("Not an std::exception\n"
"%s\n"
" FAILED in %s::test()\n\n")
% boost::current_exception_diagnostic_information () % lastname ).c_str());
fflush(stderr);
return 1;
}
printf("\n OK\n\n");
return 0;
}
int main (int argc, char * const argv[]) {
searchpaths.addAppPaths(argc, argv);
searchpaths.addSearchPath(searchpaths.appPath() + "../share");
// Logical tests; leave uncommented
// These tests are purely logical, they should not print anything out to
// the console (as it interferes with assertion error messages) or start any
// processes that require user intervention to proceed or validate the test.
// This macro runs the unit test and prints out status info
// 'Name' should match the name of the unit test, utName.
#define RUNTEST(Name)\
printf("%s ", #Name);\
ut##Name();\
for(size_t i=0; i<32-strlen(#Name); ++i) printf(".");\
printf(" pass\n")
RUNTEST(Math);
RUNTEST(MathSpherical);
RUNTEST(Types);
RUNTEST(TypesConversion);
RUNTEST(Spatial);
RUNTEST(System);
RUNTEST(ProtocolOSC);
RUNTEST(ProtocolSerialize);
RUNTEST(IOSocket);
RUNTEST(File);
RUNTEST(Thread);
RUNTEST(GraphicsMesh);
#ifndef ALLOCORE_TESTS_NO_AUDIO
RUNTEST(IOAudioIO);
RUNTEST(AudioScene);
#endif
RUNTEST(Ambisonics);
#ifndef ALLOCORE_TESTS_NO_GUI
// This test should always be run last since it calls exit()
// This test will not run on headless machines.
printf("IOWindow .... (calls exit() internally)\n");
utIOWindowGL();
#endif
// Empirical tests; leave commented
// These are tests that require some kind of observation to validate.
// utAsset();
// utGraphicsDraw();
return 0;
}
/*--- M A I N -----------------------------------------------------------*/
int
main(void)
{
bool hasFailed = false;
int rank = 0;
int size = 1;
#ifdef WITH_MPI
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
#endif
if (rank == 0) {
printf("\nTesting %s on %i %s\n",
NAME, size, size > 1 ? "tasks" : "task");
}
if (rank == 0) {
printf("\nRunning tests for refCounter:\n");
RUNTEST(&refCounter_init_test, hasFailed);
RUNTEST(&refCounter_ref_test, hasFailed);
RUNTEST(&refCounter_deref_test, hasFailed);
RUNTEST(&refCounter_noReferenceLeft_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for xstring:\n");
RUNTEST(&xstring_xdirname_test, hasFailed);
RUNTEST(&xstring_xbasename_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for endian:\n");
RUNTEST(&endian_getFileEndianessByBlock_test, hasFailed);
RUNTEST(&endian_getFileEndianessByBlockF_test, hasFailed);
RUNTEST(&endian_fileIsLittleByBlock_test, hasFailed);
RUNTEST(&endian_fileIsBigByBlock_test, hasFailed);
RUNTEST(&endian_fileIsLittleByBlockF_test, hasFailed);
RUNTEST(&endian_fileIsBigByBlockF_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for tile:\n");
RUNTEST(&tile_calcNDIdxsELAE_test, hasFailed);
RUNTEST(&tile_calcIdxsELAE_test, hasFailed);
RUNTEST(&tile_calcTileNumberForIdxELAE_test, hasFailed);
RUNTEST(&tile_calcNDIdxsELAB_test, hasFailed);
RUNTEST(&tile_calcIdxsELAB_test, hasFailed);
RUNTEST(&tile_calcTileNumberForIdxELAB_test, hasFailed);
RUNTEST(&tile_calcNumLargeTilesEven_test, hasFailed);
RUNTEST(&tile_calcNumSmallTilesEven_test, hasFailed);
RUNTEST(&tile_calcMinTileSizeEven_test, hasFailed);
RUNTEST(&tile_calcMaxTileSizeEven_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for lIdx:\n");
RUNTEST(&lIdx_fromCoord2d_test, hasFailed);
RUNTEST(&lIdx_toCoord2d_test, hasFailed);
RUNTEST(&lIdx_fromCoord3d_test, hasFailed);
RUNTEST(&lIdx_toCoord3d_test, hasFailed);
RUNTEST(&lIdx_fromCoordNd_test, hasFailed);
RUNTEST(&lIdx_toCoordNd_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for filename:\n");
RUNTEST(&filename_new_test, hasFailed);
RUNTEST(&filename_newFull_test, hasFailed);
RUNTEST(&filename_clone_test, hasFailed);
RUNTEST(&filename_del_test, hasFailed);
RUNTEST(&filename_setPath_test, hasFailed);
RUNTEST(&filename_setPrefix_test, hasFailed);
RUNTEST(&filename_setQualifier_test, hasFailed);
RUNTEST(&filename_setSuffix_test, hasFailed);
RUNTEST(&filename_getFullName_test, hasFailed);
RUNTEST(&filename_copySetFields_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for stai:\n");
RUNTEST(&stai_new_test, hasFailed);
RUNTEST(&stai_clone_test, hasFailed);
RUNTEST(&stai_cloneWithDifferentBase_test, hasFailed);
RUNTEST(&stai_del_test, hasFailed);
RUNTEST(&stai_setElement_test, hasFailed);
RUNTEST(&stai_setElementsMulti_test, hasFailed);
RUNTEST(&stai_getElement_test, hasFailed);
RUNTEST(&stai_getElementsMulti_test, hasFailed);
RUNTEST(&stai_isLinear_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for varArr:\n");
RUNTEST(&varArr_new_test, hasFailed);
RUNTEST(&varArr_del_test, hasFailed);
RUNTEST(&varArr_getLength_test, hasFailed);
RUNTEST(&varArr_insert_test, hasFailed);
RUNTEST(&varArr_remove_test, hasFailed);
RUNTEST(&varArr_replace_test, hasFailed);
RUNTEST(&varArr_getElementHandle_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for bov:\n");
RUNTEST(&bov_new_test, hasFailed);
RUNTEST(&bov_newFromFile_test, hasFailed);
RUNTEST(&bov_del_test, hasFailed);
RUNTEST(&bov_getTime_test, hasFailed);
RUNTEST(&bov_getDataFileName_test, hasFailed);
RUNTEST(&bov_getDataSize_test, hasFailed);
RUNTEST(&bov_getDataFormat_test, hasFailed);
RUNTEST(&bov_getVarName_test, hasFailed);
RUNTEST(&bov_getDataEndian_test, hasFailed);
RUNTEST(&bov_getCentering_test, hasFailed);
RUNTEST(&bov_getBrickOrigin_test, hasFailed);
RUNTEST(&bov_getBrickSize_test, hasFailed);
RUNTEST(&bov_getDataComponents_test, hasFailed);
RUNTEST(&bov_setTime_test, hasFailed);
RUNTEST(&bov_setDataFileName_test, hasFailed);
RUNTEST(&bov_setDataSize_test, hasFailed);
RUNTEST(&bov_setDataFormat_test, hasFailed);
RUNTEST(&bov_setVarName_test, hasFailed);
RUNTEST(&bov_setDataEndian_test, hasFailed);
RUNTEST(&bov_setCentering_test, hasFailed);
RUNTEST(&bov_setBrickOrigin_test, hasFailed);
RUNTEST(&bov_setBrickSize_test, hasFailed);
RUNTEST(&bov_setDataComponents_test, hasFailed);
RUNTEST(&bov_read_test, hasFailed);
RUNTEST(&bov_readWindowed_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for grafic:\n");
RUNTEST(&grafic_new_test, hasFailed);
RUNTEST(&grafic_newFromFile_test, hasFailed);
RUNTEST(&grafic_del_test, hasFailed);
RUNTEST(&grafic_getFileName_test, hasFailed);
RUNTEST(&grafic_getSize_test, hasFailed);
RUNTEST(&grafic_getDx_test, hasFailed);
RUNTEST(&grafic_getXoff_test, hasFailed);
RUNTEST(&grafic_getAstart_test, hasFailed);
RUNTEST(&grafic_getOmegam_test, hasFailed);
RUNTEST(&grafic_getOmegav_test, hasFailed);
RUNTEST(&grafic_getH0_test, hasFailed);
RUNTEST(&grafic_getIseed_test, hasFailed);
RUNTEST(&grafic_getIsWhiteNoise_test, hasFailed);
RUNTEST(&grafic_setFileName_test, hasFailed);
RUNTEST(&grafic_setSize_test, hasFailed);
RUNTEST(&grafic_setDx_test, hasFailed);
RUNTEST(&grafic_setXoff_test, hasFailed);
RUNTEST(&grafic_setAstart_test, hasFailed);
RUNTEST(&grafic_setOmegam_test, hasFailed);
RUNTEST(&grafic_setOmegav_test, hasFailed);
RUNTEST(&grafic_setH0_test, hasFailed);
RUNTEST(&grafic_setIseed_test, hasFailed);
RUNTEST(&grafic_setIsWhiteNoise_test, hasFailed);
RUNTEST(&grafic_makeEmptyFile_test, hasFailed);
RUNTEST(&grafic_read_test, hasFailed);
RUNTEST(&grafic_readWindowed_test, hasFailed);
RUNTEST(&grafic_write_test, hasFailed);
RUNTEST(&grafic_writeWindowed_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for cubepm:\n");
RUNTEST(&cubepm_new_test, hasFailed);
RUNTEST(&cubepm_del_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for gadgetVersion:\n");
RUNTEST(&gadgetVersion_getVersionFromFile_test, hasFailed);
RUNTEST(&gadgetVersion_getNameFromType_test, hasFailed);
RUNTEST(&gadgetVersion_getTypeFromName_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for gadgetBlock:\n");
RUNTEST(&gadgetBlock_getNameFromType_test, hasFailed);
RUNTEST(&gadgetBlock_getTypeFromName_test, hasFailed);
RUNTEST(&gadgetBlock_getNumComponents_test, hasFailed);
RUNTEST(&gadgetBlock_isInteger_test, hasFailed);
RUNTEST(&gadgetBlock_getNumPartsInBlock_test, hasFailed);
RUNTEST(&gadgetBlock_writereadDescriptor_test, hasFailed);
RUNTEST(&gadgetBlock_readDescriptorString_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for gadgetTOC:\n");
RUNTEST(&gadgetTOC_new_test, hasFailed);
RUNTEST(&gadgetTOC_newFromFile_test, hasFailed);
RUNTEST(&gadgetTOC_clone_test, hasFailed);
RUNTEST(&gadgetTOC_del_test, hasFailed);
RUNTEST(&gadgetTOC_setFileVersion_test, hasFailed);
RUNTEST(&gadgetTOC_getFileVersion_test, hasFailed);
RUNTEST(&gadgetTOC_blockExists_test, hasFailed);
RUNTEST(&gadgetTOC_blockExistsByName_test, hasFailed);
RUNTEST(&gadgetTOC_getOffsetForBlock_test, hasFailed);
RUNTEST(&gadgetTOC_getSizeInBytesForBlock_test, hasFailed);
RUNTEST(&gadgetTOC_getNameInV2FilesForBlock_test, hasFailed);
RUNTEST(&gadgetTOC_getOffsetBySeqNumber_test, hasFailed);
RUNTEST(&gadgetTOC_getTypeBySeqNumber_test, hasFailed);
RUNTEST(&gadgetTOC_getSizeInBytesBySeqNumber_test, hasFailed);
RUNTEST(&gadgetTOC_getNameBySeqNumber_test, hasFailed);
RUNTEST(&gadgetTOC_getTotalFileSize_test, hasFailed);
RUNTEST(&gadgetTOC_addEntryByName_test, hasFailed);
RUNTEST(&gadgetTOC_addEntryByType_test, hasFailed);
RUNTEST(&gadgetTOC_calcSizes_test, hasFailed);
RUNTEST(&gadgetTOC_calcOffset_test, hasFailed);
RUNTEST(&gadgetTOC_seekToData_test, hasFailed);
RUNTEST(&gadgetTOC_seekToDescriptor_test, hasFailed);
RUNTEST(&gadgetTOC_isValid_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for gadgetHeader:\n");
RUNTEST(&gadgetHeader_new_test, hasFailed);
RUNTEST(&gadgetHeader_del_test, hasFailed);
RUNTEST(&gadgetHeader_setNall_test, hasFailed);
RUNTEST(&gadgetHeader_getNumPartsInFileWithMass_test, hasFailed);
RUNTEST(&gadgetHeader_getNumPartsInBlock_test, hasFailed);
RUNTEST(&gadgetHeader_sizeOfElement_test, hasFailed);
}
if (rank == 0) {
printf("\nRunning tests for gadget:\n");
RUNTEST(&gadget_new_test, hasFailed);
RUNTEST(&gadget_newSimple_test, hasFailed);
RUNTEST(&gadget_del_test, hasFailed);
RUNTEST(&gadget_writeHeaderToCurrentFile_test, hasFailed);
RUNTEST(&gadget_writeBlockToCurrentFile_test, hasFailed);
}
#ifdef WITH_MPI
MPI_Barrier(MPI_COMM_WORLD);
if (rank == 0) {
printf("\nRunning tests for commSchemeBuffer:\n");
}
RUNTESTMPI(&commSchemeBuffer_new_test, hasFailed);
RUNTESTMPI(&commSchemeBuffer_del_test, hasFailed);
RUNTESTMPI(&commSchemeBuffer_getBuf_test, hasFailed);
RUNTESTMPI(&commSchemeBuffer_getCount_test, hasFailed);
RUNTESTMPI(&commSchemeBuffer_getDatatype_test, hasFailed);
RUNTESTMPI(&commSchemeBuffer_getRank_test, hasFailed);
if (rank == 0) {
printf("\nRunning tests for commScheme:\n");
}
RUNTESTMPI(&commScheme_new_test, hasFailed);
RUNTESTMPI(&commScheme_del_test, hasFailed);
RUNTESTMPI(&commScheme_addBuffer_test, hasFailed);
RUNTESTMPI(&commScheme_fire_test, hasFailed);
RUNTESTMPI(&commScheme_fireBlock_test, hasFailed);
RUNTESTMPI(&commScheme_wait_test, hasFailed);
if (rank == 0)
printf("\nRunning tests for groupi:\n");
RUNTESTMPI(&groupi_new_test, hasFailed);
RUNTESTMPI(&groupi_del_test, hasFailed);
RUNTESTMPI(&groupi_test, hasFailed);
MPI_Finalize();
#endif
if (hasFailed) {
if (rank == 0)
fprintf(stderr, "\nSome tests failed!\n\n");
return EXIT_FAILURE;
}
if (rank == 0)
printf("\nAll tests passed successfully!\n\n");
return EXIT_SUCCESS;
} /* main */
int UnitTest::
test()
{
try {
Timer(); // Init performance counting
TaskTimer tt("Running tests");
trace_perf::add_database_path("../lib/backtrace/trace_perf");
trace_perf::add_database_path("../lib/gpumisc/trace_perf");
trace_perf::add_database_path("../lib/heightmap/trace_perf");
trace_perf::add_database_path("../lib/tfr/trace_perf");
RUNTEST(BacktraceTest::UnitTest);
RUNTEST(JustMisc::UnitTest);
RUNTEST(gpumisc::UnitTest);
RUNTEST(Signal::UnitTest);
RUNTEST(Tfr::UnitTest);
RUNTEST(Heightmap::UnitTest);
RUNTEST(Test::ImplicitOrdering);
RUNTEST(Test::Stdlibtest);
RUNTEST(Test::TaskTimerTiming);
RUNTEST(Test::RandomBuffer);
RUNTEST(Test::PrintBuffer);
RUNTEST(Signal::Buffer);
RUNTEST(Signal::BufferSource);
RUNTEST(Tfr::FreqAxis);
RUNTEST(Gauss);
// PortAudio complains if testing Microphone in the end
RUNTEST(Adapters::MicrophoneRecorderDesc);
RUNTEST(Filters::Selection);
RUNTEST(Filters::EnvelopeDesc);
RUNTEST(Filters::Normalize);
RUNTEST(Filters::Rectangle);
RUNTEST(Filters::TimeSelection);
RUNTEST(Tools::OpenfileController);
RUNTEST(Tools::OpenWatchedFileController);
RUNTEST(Tools::RecordModel);
RUNTEST(Tools::Support::AudiofileOpener);
RUNTEST(Tools::Support::CsvfileOpener);
RUNTEST(Tools::Support::ChainInfo);
RUNTEST(Tools::Support::OperationCrop);
RUNTEST(Tools::Support::RenderOperationDesc);
RUNTEST(Tools::Support::RenderViewUpdateAdapter);
RUNTEST(Tools::Support::HeightmapProcessingPublisher);
RUNTEST(Tools::Support::WorkerCrashLogger);
RUNTEST(Tools::Support::ComputeRmsDesc);
RUNTEST(Tools::Commands::AppendOperationDescCommand);
RUNTEST(Tools::ApplicationErrorLogController);
RUNTEST(Adapters::Playback);
RUNTEST(Filters::AbsoluteValueDesc);
} catch (const ExceptionAssert& x) {
char const * const * f = boost::get_error_info<boost::throw_file>(x);
int const * l = boost::get_error_info<boost::throw_line>(x);
char const * const * c = boost::get_error_info<ExceptionAssert::ExceptionAssert_condition>(x);
std::string const * m = boost::get_error_info<ExceptionAssert::ExceptionAssert_message>(x);
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s:%d: %s. %s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% (f?*f:0) % (l?*l:-1) % (c?*c:0) % (m?*m:0) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (const exception& x) {
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("%s\n"
"%s\n"
" FAILED in %s::test()\n\n")
% vartype(x) % boost::diagnostic_information(x) % lastname ).c_str());
fflush(stderr);
return 1;
} catch (...) {
fflush(stdout);
fprintf(stderr, "%s",
str(boost::format("Not an std::exception\n"
"%s\n"
" FAILED in %s::test()\n\n")
% boost::current_exception_diagnostic_information () % lastname ).c_str());
fflush(stderr);
return 1;
}
printf("\n OK\n\n");
return 0;
}
