/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2011,2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "testutils/datatest.h"
#include "testutils/mock_datamodule.h"
+#include "testutils/testasserts.h"
using gmx::test::MockAnalysisDataModule;
using gmx::test::MockAnalysisDataModulePointer;
data.setColumnCount(2);
MockAnalysisDataModulePointer mod1(new MockAnalysisDataModule(0));
- EXPECT_THROW(data.addModule(mod1), gmx::APIError);
+ EXPECT_THROW_GMX(data.addModule(mod1), gmx::APIError);
MockAnalysisDataModulePointer mod2(
new MockAnalysisDataModule(gmx::AnalysisDataModuleInterface::efAllowMulticolumn));
- EXPECT_NO_THROW(data.addModule(mod2));
+ EXPECT_NO_THROW_GMX(data.addModule(mod2));
}
/*
data.setMultipoint(true);
MockAnalysisDataModulePointer mod1(new MockAnalysisDataModule(0));
- EXPECT_THROW(data.addModule(mod1), gmx::APIError);
+ EXPECT_THROW_GMX(data.addModule(mod1), gmx::APIError);
MockAnalysisDataModulePointer mod2(
new MockAnalysisDataModule(gmx::AnalysisDataModuleInterface::efAllowMultipoint));
- EXPECT_NO_THROW(data.addModule(mod2));
+ EXPECT_NO_THROW_GMX(data.addModule(mod2));
}
gmx::AnalysisData data;
data.setColumnCount(input.columnCount());
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
/*
gmx::AnalysisData data;
data.setColumnCount(input.columnCount());
- ASSERT_NO_THROW(addStaticColumnCheckerModule(input, 0, 2, &data));
- ASSERT_NO_THROW(addStaticColumnCheckerModule(input, 2, 1, &data));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticColumnCheckerModule(input, 0, 2, &data));
+ ASSERT_NO_THROW_GMX(addStaticColumnCheckerModule(input, 2, 1, &data));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
/*
gmx::AnalysisData data;
data.setColumnCount(input.columnCount());
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addStaticColumnCheckerModule(input, 1, 2, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticColumnCheckerModule(input, 1, 2, &data));
gmx::AnalysisDataHandle handle1;
gmx::AnalysisDataHandle handle2;
gmx::AnalysisDataParallelOptions options(2);
- ASSERT_NO_THROW(handle1 = data.startData(options));
- ASSERT_NO_THROW(handle2 = data.startData(options));
- ASSERT_NO_THROW(presentDataFrame(input, 1, handle1));
- ASSERT_NO_THROW(presentDataFrame(input, 0, handle2));
- ASSERT_NO_THROW(presentDataFrame(input, 2, handle1));
- ASSERT_NO_THROW(handle1.finishData());
- ASSERT_NO_THROW(handle2.finishData());
+ ASSERT_NO_THROW_GMX(handle1 = data.startData(options));
+ ASSERT_NO_THROW_GMX(handle2 = data.startData(options));
+ ASSERT_NO_THROW_GMX(presentDataFrame(input, 1, handle1));
+ ASSERT_NO_THROW_GMX(presentDataFrame(input, 0, handle2));
+ ASSERT_NO_THROW_GMX(presentDataFrame(input, 2, handle1));
+ ASSERT_NO_THROW_GMX(handle1.finishData());
+ ASSERT_NO_THROW_GMX(handle2.finishData());
}
/*
gmx::AnalysisData data;
data.setColumnCount(input.columnCount());
- ASSERT_NO_THROW(addStaticStorageCheckerModule(input, -1, &data));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticStorageCheckerModule(input, -1, &data));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
/*
data.setColumnCount(input.columnCount());
ASSERT_TRUE(data.requestStorage(-1));
- ASSERT_NO_THROW(presentAllData(input, &data));
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
}
/*
gmx::AnalysisData data;
data.setColumnCount(input.columnCount());
- ASSERT_NO_THROW(addStaticStorageCheckerModule(input, 1, &data));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticStorageCheckerModule(input, 1, &data));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
//! Input data for multipoint gmx::AnalysisData tests.
data.setColumnCount(input.columnCount());
data.setMultipoint(true);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
/*
data.setColumnCount(input.columnCount());
data.setMultipoint(true);
- ASSERT_NO_THROW(addStaticColumnCheckerModule(input, 0, 2, &data));
- ASSERT_NO_THROW(addStaticColumnCheckerModule(input, 2, 1, &data));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticColumnCheckerModule(input, 0, 2, &data));
+ ASSERT_NO_THROW_GMX(addStaticColumnCheckerModule(input, 2, 1, &data));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
} // namespace
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "gromacs/analysisdata/arraydata.h"
#include "testutils/datatest.h"
+#include "testutils/testasserts.h"
namespace
{
data.setXAxis(1.0, 1.0);
setupArrayData(input, &data);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(data.valuesReady());
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(data.valuesReady());
}
TEST_F(AnalysisArrayDataTest, StorageWorks)
data.setXAxis(1.0, 1.0);
setupArrayData(input, &data);
- ASSERT_NO_THROW(addStaticStorageCheckerModule(input, -1, &data));
- ASSERT_NO_THROW(data.valuesReady());
+ ASSERT_NO_THROW_GMX(addStaticStorageCheckerModule(input, -1, &data));
+ ASSERT_NO_THROW_GMX(data.valuesReady());
}
} // namespace
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "gromacs/analysisdata/modules/average.h"
#include "testutils/datatest.h"
+#include "testutils/testasserts.h"
namespace
{
new gmx::AnalysisDataAverageModule);
data.addModule(module);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Average", module.get()));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Average", module.get()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
TEST_F(AverageModuleTest, HandlesMultipointData)
new gmx::AnalysisDataAverageModule);
data.addModule(module);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Average", module.get()));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Average", module.get()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
TEST_F(AverageModuleTest, CanCustomizeXAxis)
data.addModule(module);
module->setXAxis(0.5, 0.5);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Average", module.get()));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Average", module.get()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
/********************************************************************
new gmx::AnalysisDataFrameAverageModule);
data.addModule(module);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("FrameAverage", module.get()));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("FrameAverage", module.get()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
} // namespace
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "gromacs/analysisdata/modules/histogram.h"
#include "testutils/datatest.h"
+#include "testutils/testasserts.h"
namespace
{
gmx::histogramFromRange(1.0, 3.0).binCount(4)));
data.addModule(module);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
- ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
- &module->averager()));
- ASSERT_NO_THROW(presentAllData(input, &data));
- ASSERT_NO_THROW(module->averager().done());
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
+ &module->averager()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(module->averager().done());
}
gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
data.addModule(module);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
- ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
- &module->averager()));
- ASSERT_NO_THROW(presentAllData(input, &data));
- ASSERT_NO_THROW(module->averager().done());
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
+ &module->averager()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(module->averager().done());
}
gmx::histogramFromRange(1.0, 3.0).binCount(4)));
data.addModule(module);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
- ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
- &module->averager()));
- ASSERT_NO_THROW(presentAllData(input, &data));
- ASSERT_NO_THROW(module->averager().done());
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
+ &module->averager()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(module->averager().done());
}
gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
data.addModule(module);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
- ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
- &module->averager()));
- ASSERT_NO_THROW(presentAllData(input, &data));
- ASSERT_NO_THROW(module->averager().done());
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
+ &module->averager()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(module->averager().done());
}
gmx::histogramFromRange(1.0, 3.0).binCount(4)));
data.addModule(module);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module.get()));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
data.addModule(module);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module.get()));
- ASSERT_NO_THROW(presentAllData(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
+ ASSERT_NO_THROW_GMX(presentAllData(input, &data));
}
gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
setupArrayData(input, &data);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
gmx::AverageHistogramPointer copy(data.clone());
- ASSERT_NO_THROW(addStaticCheckerModule(input, copy.get()));
- ASSERT_NO_THROW(copy->done());
- ASSERT_NO_THROW(data.done());
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy.get()));
+ ASSERT_NO_THROW_GMX(copy->done());
+ ASSERT_NO_THROW_GMX(data.done());
gmx::AverageHistogramPointer copy2(data.clone());
- ASSERT_NO_THROW(addStaticCheckerModule(input, copy2.get()));
- ASSERT_NO_THROW(copy2->done());
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy2.get()));
+ ASSERT_NO_THROW_GMX(copy2->done());
}
gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
setupArrayData(input, &data);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
- ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
- ASSERT_NO_THROW(data.done());
- ASSERT_NO_THROW(resampled->done());
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
+ ASSERT_NO_THROW_GMX(data.done());
+ ASSERT_NO_THROW_GMX(resampled->done());
}
gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
setupArrayData(input, &data);
- ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
- ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
+ ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
- ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
- ASSERT_NO_THROW(data.done());
- ASSERT_NO_THROW(resampled->done());
+ ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
+ ASSERT_NO_THROW_GMX(data.done());
+ ASSERT_NO_THROW_GMX(resampled->done());
}
} // namespace
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "testutils/cmdlinetest.h"
#include "testutils/mock_helptopic.h"
+#include "testutils/testasserts.h"
namespace
{
EXPECT_CALL(mod1, run(_, _))
.With(Args<1, 0>(ElementsAreArray(args.argv() + 1, args.argc() - 1)));
int rc = 0;
- ASSERT_NO_THROW(rc = manager().run(args.argc(), args.argv()));
+ ASSERT_NO_THROW_GMX(rc = manager().run(args.argc(), args.argv()));
ASSERT_EQ(0, rc);
}
using ::testing::_;
EXPECT_CALL(mod1, writeHelp(_));
int rc = 0;
- ASSERT_NO_THROW(rc = manager().run(args.argc(), args.argv()));
+ ASSERT_NO_THROW_GMX(rc = manager().run(args.argc(), args.argv()));
ASSERT_EQ(0, rc);
}
using ::testing::_;
EXPECT_CALL(topic, writeHelp(_));
int rc = 0;
- ASSERT_NO_THROW(rc = manager().run(args.argc(), args.argv()));
+ ASSERT_NO_THROW_GMX(rc = manager().run(args.argc(), args.argv()));
ASSERT_EQ(0, rc);
}
EXPECT_CALL(mod1, run(_, _))
.With(Args<1, 0>(ElementsAreArray(args.argv(), args.argc())));
int rc = 0;
- ASSERT_NO_THROW(rc = manager().run(args.argc(), args.argv()));
+ ASSERT_NO_THROW_GMX(rc = manager().run(args.argc(), args.argv()));
ASSERT_EQ(0, rc);
}
EXPECT_CALL(mod1, run(_, _))
.With(Args<1, 0>(ElementsAreArray(args.argv(), args.argc())));
int rc = 0;
- ASSERT_NO_THROW(rc = manager().run(args.argc(), args.argv()));
+ ASSERT_NO_THROW_GMX(rc = manager().run(args.argc(), args.argv()));
ASSERT_EQ(0, rc);
}
EXPECT_CALL(mod1, run(_, _))
.With(Args<1, 0>(ElementsAreArray(args.argv() + 1, args.argc() - 1)));
int rc = 0;
- ASSERT_NO_THROW(rc = manager().run(args.argc(), args.argv()));
+ ASSERT_NO_THROW_GMX(rc = manager().run(args.argc(), args.argv()));
ASSERT_EQ(0, rc);
}
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2010,2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2010,2011,2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "gromacs/options/options.h"
#include "testutils/cmdlinetest.h"
+#include "testutils/testasserts.h"
namespace
{
"test", "-flag", "yes", "-mvi", "2", "-mvd", "2.7"
};
CommandLine args(CommandLine::create(cmdline));
- ASSERT_NO_THROW(parser_.parse(&args.argc(), args.argv()));
- ASSERT_NO_THROW(options_.finish());
+ ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
+ ASSERT_NO_THROW_GMX(options_.finish());
EXPECT_TRUE(flag_);
ASSERT_EQ(1U, ivalues_.size());
"test", "-mvi", "1", "-2", "-mvd", "-2.7"
};
CommandLine args(CommandLine::create(cmdline));
- ASSERT_NO_THROW(parser_.parse(&args.argc(), args.argv()));
- ASSERT_NO_THROW(options_.finish());
+ ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
+ ASSERT_NO_THROW_GMX(options_.finish());
ASSERT_EQ(2U, ivalues_.size());
EXPECT_EQ(1, ivalues_[0]);
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "testutils/mock_helptopic.h"
#include "testutils/stringtest.h"
+#include "testutils/testasserts.h"
#include "testutils/testfilemanager.h"
namespace
using ::testing::_;
EXPECT_CALL(firstSub, writeHelp(_));
- ASSERT_NO_THROW(manager_.enterTopic("first"));
- ASSERT_NO_THROW(manager_.enterTopic("firstsub"));
+ ASSERT_NO_THROW_GMX(manager_.enterTopic("first"));
+ ASSERT_NO_THROW_GMX(manager_.enterTopic("firstsub"));
manager_.writeCurrentTopic();
}
first.addSubTopic("firstsub", "First subtopic", "First subtopic text");
rootTopic_.addSubTopic("second", "Second topic", "Second topic text");
- ASSERT_THROW(manager_.enterTopic("unknown"), gmx::InvalidInputError);
- ASSERT_NO_THROW(manager_.enterTopic("first"));
- ASSERT_THROW(manager_.enterTopic("unknown"), gmx::InvalidInputError);
- ASSERT_THROW(manager_.enterTopic("second"), gmx::InvalidInputError);
- ASSERT_NO_THROW(manager_.enterTopic("firstsub"));
+ ASSERT_THROW_GMX(manager_.enterTopic("unknown"), gmx::InvalidInputError);
+ ASSERT_NO_THROW_GMX(manager_.enterTopic("first"));
+ ASSERT_THROW_GMX(manager_.enterTopic("unknown"), gmx::InvalidInputError);
+ ASSERT_THROW_GMX(manager_.enterTopic("second"), gmx::InvalidInputError);
+ ASSERT_NO_THROW_GMX(manager_.enterTopic("firstsub"));
}
/********************************************************************
void HelpTopicFormattingTest::checkHelpFormatting()
{
- ASSERT_NO_THROW(manager_.enterTopic("testtopic"));
- ASSERT_NO_THROW(manager_.writeCurrentTopic());
+ ASSERT_NO_THROW_GMX(manager_.enterTopic("testtopic"));
+ ASSERT_NO_THROW_GMX(manager_.writeCurrentTopic());
helpFile_.close();
checkFileContents(filename_, "HelpText");
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2010,2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2010,2011,2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "gromacs/options/optionstoragetemplate.h"
#include "gromacs/options/optionsassigner.h"
#include "gromacs/utility/exceptions.h"
+
+#include "testutils/testasserts.h"
#include "testutils/testexceptions.h"
namespace
}
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
ASSERT_EQ(1U, values.size());
EXPECT_EQ("dummy", values[0]);
}
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("name"));
- EXPECT_NO_THROW(assigner.appendValue("a"));
- EXPECT_NO_THROW(assigner.appendValue("b"));
- EXPECT_NO_THROW(assigner.appendValue("c"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("name"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("a"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("b"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("c"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
ASSERT_EQ(2U, values.size());
EXPECT_EQ("a", values[0]);
}
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("name"));
- EXPECT_NO_THROW(assigner.appendValue("a"));
- EXPECT_NO_THROW(assigner.appendValue("b"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("name"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("a"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("b"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
ASSERT_EQ(3U, values.size());
EXPECT_EQ("a", values[0]);
}
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("name"));
- EXPECT_NO_THROW(assigner.appendValue("a"));
- EXPECT_THROW(assigner.appendValue("b"), gmx::InvalidInputError);
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("name"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("a"));
+ EXPECT_THROW_GMX(assigner.appendValue("b"), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
ASSERT_TRUE(values.empty());
}
}
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- EXPECT_NO_THROW(assigner.startOption("name"));
- EXPECT_NO_THROW(assigner.appendValue("a"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ EXPECT_NO_THROW_GMX(assigner.startOption("name"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("a"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
ASSERT_EQ(0U, values.size());
}
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "gromacs/utility/exceptions.h"
#include "gromacs/utility/file.h"
+#include "testutils/testasserts.h"
#include "testutils/testfilemanager.h"
namespace
{
gmx::Options options(NULL, NULL);
std::string value;
- ASSERT_NO_THROW(options.addOption(
- FileNameOption("f").store(&value)
- .filetype(gmx::eftTrajectory).outputFile()));
+ ASSERT_NO_THROW_GMX(options.addOption(
+ FileNameOption("f").store(&value)
+ .filetype(gmx::eftTrajectory).outputFile()));
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- EXPECT_NO_THROW(assigner.startOption("f"));
- EXPECT_NO_THROW(assigner.appendValue("testfile"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ EXPECT_NO_THROW_GMX(assigner.startOption("f"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("testfile"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
EXPECT_EQ("testfile.xtc", value);
}
{
gmx::Options options(NULL, NULL);
std::string value;
- ASSERT_NO_THROW(options.addOption(
- FileNameOption("f").store(&value).required()
- .filetype(gmx::eftGenericData).outputFile()
- .defaultBasename("testfile")));
+ ASSERT_NO_THROW_GMX(options.addOption(
+ FileNameOption("f").store(&value).required()
+ .filetype(gmx::eftGenericData).outputFile()
+ .defaultBasename("testfile")));
EXPECT_EQ("testfile.dat", value);
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
EXPECT_EQ("testfile.dat", value);
}
{
gmx::Options options(NULL, NULL);
std::string value;
- ASSERT_NO_THROW(options.addOption(
- FileNameOption("f").store(&value)
- .filetype(gmx::eftIndex).outputFile()
- .defaultBasename("testfile")));
+ ASSERT_NO_THROW_GMX(options.addOption(
+ FileNameOption("f").store(&value)
+ .filetype(gmx::eftIndex).outputFile()
+ .defaultBasename("testfile")));
EXPECT_TRUE(value.empty());
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- EXPECT_NO_THROW(assigner.startOption("f"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ EXPECT_NO_THROW_GMX(assigner.startOption("f"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
EXPECT_EQ("testfile.ndx", value);
}
{
gmx::Options options(NULL, NULL);
std::string value;
- ASSERT_NO_THROW(options.addOption(
- FileNameOption("f").store(&value)
- .filetype(gmx::eftTrajectory).inputFile()));
+ ASSERT_NO_THROW_GMX(options.addOption(
+ FileNameOption("f").store(&value)
+ .filetype(gmx::eftTrajectory).inputFile()));
TestFileManager tempFiles;
std::string filename(tempFiles.getTemporaryFilePath(".trr"));
gmx::File::writeFileFromString(filename, "Dummy trajectory file");
std::string inputValue(filename.substr(0, filename.length() - 4));
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- EXPECT_NO_THROW(assigner.startOption("f"));
- EXPECT_NO_THROW(assigner.appendValue(inputValue));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ EXPECT_NO_THROW_GMX(assigner.startOption("f"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue(inputValue));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
EXPECT_EQ(filename, value);
}
#include "gromacs/options/options.h"
#include "gromacs/utility/exceptions.h"
+#include "testutils/testasserts.h"
+
namespace
{
gmx::Options options(NULL, NULL);
int value = -1;
using gmx::IntegerOption;
- ASSERT_THROW(options.addOption(IntegerOption("name").store(&value)
- .multiValue()),
- gmx::APIError);
+ ASSERT_THROW_GMX(options.addOption(IntegerOption("name").store(&value)
+ .multiValue()),
+ gmx::APIError);
}
TEST(OptionsTest, FailsOnIncorrectEnumDefaultValue)
std::string value;
const char * const allowed[] = { "none", "test", "value" };
using gmx::StringOption;
- ASSERT_THROW(options.addOption(StringOption("name").store(&value)
- .enumValue(allowed)
- .defaultValue("unknown")),
- gmx::APIError);
+ ASSERT_THROW_GMX(options.addOption(StringOption("name").store(&value)
+ .enumValue(allowed)
+ .defaultValue("unknown")),
+ gmx::APIError);
}
} // namespace
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "gromacs/options/optionsassigner.h"
#include "gromacs/options/timeunitmanager.h"
+#include "testutils/testasserts.h"
+
namespace
{
gmx::Options options(NULL, NULL);
double value = 0.0;
using gmx::DoubleOption;
- ASSERT_NO_THROW(options.addOption(DoubleOption("p").store(&value).timeValue()));
+ ASSERT_NO_THROW_GMX(options.addOption(DoubleOption("p").store(&value).timeValue()));
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("p"));
- ASSERT_NO_THROW(assigner.appendValue("1.5"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("p"));
+ ASSERT_NO_THROW_GMX(assigner.appendValue("1.5"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
EXPECT_DOUBLE_EQ(1.5, value);
manager.setTimeUnit(gmx::eTimeUnit_ns);
manager.scaleTimeOptions(&options);
EXPECT_DOUBLE_EQ(1500, value);
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
manager.setTimeUnit(gmx::eTimeUnit_us);
manager.scaleTimeOptions(&options);
gmx::Options options(NULL, NULL);
double value = 1.5, value2 = 0.0;
using gmx::DoubleOption;
- ASSERT_NO_THROW(options.addOption(DoubleOption("p").store(&value).timeValue()));
- ASSERT_NO_THROW(options.addOption(DoubleOption("q").store(&value2).timeValue()
- .defaultValueIfSet(2.5)));
+ ASSERT_NO_THROW_GMX(options.addOption(DoubleOption("p").store(&value).timeValue()));
+ ASSERT_NO_THROW_GMX(options.addOption(DoubleOption("q").store(&value2).timeValue()
+ .defaultValueIfSet(2.5)));
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("q"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("q"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
EXPECT_DOUBLE_EQ(2.5, value2);
manager.setTimeUnit(gmx::eTimeUnit_ns);
gmx::Options options(NULL, NULL);
double value = 0.0;
using gmx::DoubleOption;
- ASSERT_NO_THROW(options.addOption(DoubleOption("p").store(&value).timeValue()));
+ ASSERT_NO_THROW_GMX(options.addOption(DoubleOption("p").store(&value).timeValue()));
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("p"));
- ASSERT_NO_THROW(assigner.appendValue("1.5"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("p"));
+ ASSERT_NO_THROW_GMX(assigner.appendValue("1.5"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
gmx::OptionsAssigner assigner2(&options);
- EXPECT_NO_THROW(assigner2.start());
- EXPECT_NO_THROW(assigner2.finish());
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(assigner2.start());
+ EXPECT_NO_THROW_GMX(assigner2.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
EXPECT_DOUBLE_EQ(1.5, value);
manager.setTimeUnit(gmx::eTimeUnit_ns);
gmx::Options options(NULL, NULL);
double value = 0.0;
using gmx::DoubleOption;
- ASSERT_NO_THROW(options.addOption(DoubleOption("p").store(&value).timeValue()));
- ASSERT_NO_THROW(manager.addTimeUnitOption(&options, "tu"));
+ ASSERT_NO_THROW_GMX(options.addOption(DoubleOption("p").store(&value).timeValue()));
+ ASSERT_NO_THROW_GMX(manager.addTimeUnitOption(&options, "tu"));
gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("p"));
- ASSERT_NO_THROW(assigner.appendValue("1.5"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("tu"));
- ASSERT_NO_THROW(assigner.appendValue("ns"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("p"));
+ ASSERT_NO_THROW_GMX(assigner.appendValue("1.5"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("tu"));
+ ASSERT_NO_THROW_GMX(assigner.appendValue("ns"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
EXPECT_DOUBLE_EQ(1.5, value);
EXPECT_EQ(gmx::eTimeUnit_ns, manager.timeUnit());
manager.scaleTimeOptions(&options);
EXPECT_DOUBLE_EQ(1500, value);
- EXPECT_NO_THROW(options.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
}
} // namespace
#include "gromacs/utility/stringutil.h"
#include "testutils/refdata.h"
+#include "testutils/testasserts.h"
#include "testutils/testfilemanager.h"
#include "testutils/testoptions.h"
void setAtomCount(int natoms)
{
- ASSERT_NO_THROW(sc_.setTopology(NULL, natoms));
+ ASSERT_NO_THROW_GMX(sc_.setTopology(NULL, natoms));
}
void loadTopology(const char *filename);
sfree(xtop);
- ASSERT_NO_THROW(sc_.setTopology(top_, -1));
+ ASSERT_NO_THROW_GMX(sc_.setTopology(top_, -1));
}
SCOPED_TRACE(std::string("Parsing selection \"")
+ selections[i] + "\"");
gmx::SelectionList result;
- ASSERT_NO_THROW(result = sc_.parseFromString(selections[i]));
+ ASSERT_NO_THROW_GMX(result = sc_.parseFromString(selections[i]));
sel_.insert(sel_.end(), result.begin(), result.end());
if (sel_.size() == count_)
{
void
SelectionCollectionDataTest::runCompiler()
{
- ASSERT_NO_THROW(sc_.compile());
+ ASSERT_NO_THROW_GMX(sc_.compile());
ASSERT_EQ(count_, sel_.size());
checkCompiled();
}
using gmx::test::TestReferenceChecker;
++framenr_;
- ASSERT_NO_THROW(sc_.evaluate(frame_, NULL));
+ ASSERT_NO_THROW_GMX(sc_.evaluate(frame_, NULL));
std::string frame = gmx::formatString("Frame%d", framenr_);
TestReferenceChecker compound(
checker_.checkCompound("EvaluatedSelections", frame.c_str()));
void
SelectionCollectionDataTest::runEvaluateFinal()
{
- ASSERT_NO_THROW(sc_.evaluateFinal(framenr_));
+ ASSERT_NO_THROW_GMX(sc_.evaluateFinal(framenr_));
if (!checker_.isWriteMode())
{
checkCompiled();
TEST_F(SelectionCollectionTest, HandlesNoSelections)
{
EXPECT_FALSE(sc_.requiresTopology());
- EXPECT_NO_THROW(sc_.compile());
+ EXPECT_NO_THROW_GMX(sc_.compile());
}
TEST_F(SelectionCollectionTest, HandlesVelocityAndForceRequests)
{
- ASSERT_NO_THROW(sel_ = sc_.parseFromString("atomnr 1 to 10; none"));
+ ASSERT_NO_THROW_GMX(sel_ = sc_.parseFromString("atomnr 1 to 10; none"));
ASSERT_NO_FATAL_FAILURE(setAtomCount(10));
ASSERT_EQ(2U, sel_.size());
- ASSERT_NO_THROW(sel_[0].setEvaluateVelocities(true));
- ASSERT_NO_THROW(sel_[1].setEvaluateVelocities(true));
- ASSERT_NO_THROW(sel_[0].setEvaluateForces(true));
- ASSERT_NO_THROW(sel_[1].setEvaluateForces(true));
- ASSERT_NO_THROW(sc_.compile());
+ ASSERT_NO_THROW_GMX(sel_[0].setEvaluateVelocities(true));
+ ASSERT_NO_THROW_GMX(sel_[1].setEvaluateVelocities(true));
+ ASSERT_NO_THROW_GMX(sel_[0].setEvaluateForces(true));
+ ASSERT_NO_THROW_GMX(sel_[1].setEvaluateForces(true));
+ ASSERT_NO_THROW_GMX(sc_.compile());
EXPECT_TRUE(sel_[0].hasVelocities());
EXPECT_TRUE(sel_[1].hasVelocities());
EXPECT_TRUE(sel_[0].hasForces());
TEST_F(SelectionCollectionTest, ParsesSelectionsFromFile)
{
- ASSERT_NO_THROW(sel_ = sc_.parseFromFile(
- gmx::test::TestFileManager::getInputFilePath("selfile.dat")));
+ ASSERT_NO_THROW_GMX(sel_ = sc_.parseFromFile(
+ gmx::test::TestFileManager::getInputFilePath("selfile.dat")));
// These should match the contents of selfile.dat
ASSERT_EQ(2U, sel_.size());
EXPECT_STREQ("resname RA RB", sel_[0].selectionText());
TEST_F(SelectionCollectionTest, HandlesInvalidRegularExpressions)
{
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- EXPECT_THROW({
- sc_.parseFromString("resname ~ \"R[A\"");
- sc_.compile();
- }, gmx::InvalidInputError);
+ EXPECT_THROW_GMX({
+ sc_.parseFromString("resname ~ \"R[A\"");
+ sc_.compile();
+ }, gmx::InvalidInputError);
}
TEST_F(SelectionCollectionTest, HandlesUnsupportedRegularExpressions)
if (!gmx::Regex::isSupported())
{
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- EXPECT_THROW({
- sc_.parseFromString("resname \"R[AD]\"");
- sc_.compile();
- }, gmx::InvalidInputError);
+ EXPECT_THROW_GMX({
+ sc_.parseFromString("resname \"R[AD]\"");
+ sc_.compile();
+ }, gmx::InvalidInputError);
}
}
TEST_F(SelectionCollectionTest, HandlesMissingMethodParamValue)
{
- EXPECT_THROW(sc_.parseFromString("mindist from atomnr 1 cutoff"),
- gmx::InvalidInputError);
+ EXPECT_THROW_GMX(sc_.parseFromString("mindist from atomnr 1 cutoff"),
+ gmx::InvalidInputError);
}
TEST_F(SelectionCollectionTest, HandlesMissingMethodParamValue2)
{
- EXPECT_THROW(sc_.parseFromString("within 1 of"),
- gmx::InvalidInputError);
+ EXPECT_THROW_GMX(sc_.parseFromString("within 1 of"),
+ gmx::InvalidInputError);
}
TEST_F(SelectionCollectionTest, HandlesMissingMethodParamValue3)
{
- EXPECT_THROW(sc_.parseFromString("within of atomnr 1"),
- gmx::InvalidInputError);
+ EXPECT_THROW_GMX(sc_.parseFromString("within of atomnr 1"),
+ gmx::InvalidInputError);
}
TEST_F(SelectionCollectionTest, HandlesHelpKeywordInInvalidContext)
{
- EXPECT_THROW(sc_.parseFromString("resname help"),
- gmx::InvalidInputError);
+ EXPECT_THROW_GMX(sc_.parseFromString("resname help"),
+ gmx::InvalidInputError);
}
// TODO: Tests for more parser errors
TEST_F(SelectionCollectionTest, RecoversFromUnknownGroupReference)
{
- ASSERT_NO_THROW(sc_.parseFromString("group \"foo\""));
+ ASSERT_NO_THROW_GMX(sc_.parseFromString("group \"foo\""));
ASSERT_NO_FATAL_FAILURE(setAtomCount(10));
- EXPECT_THROW(sc_.setIndexGroups(NULL), gmx::InvalidInputError);
- EXPECT_THROW(sc_.compile(), gmx::APIError);
+ EXPECT_THROW_GMX(sc_.setIndexGroups(NULL), gmx::InvalidInputError);
+ EXPECT_THROW_GMX(sc_.compile(), gmx::APIError);
}
TEST_F(SelectionCollectionTest, RecoversFromMissingMoleculeInfo)
{
- ASSERT_NO_THROW(sc_.parseFromString("molindex 1 to 5"));
+ ASSERT_NO_THROW_GMX(sc_.parseFromString("molindex 1 to 5"));
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- EXPECT_THROW(sc_.compile(), gmx::InconsistentInputError);
+ EXPECT_THROW_GMX(sc_.compile(), gmx::InconsistentInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromMissingAtomTypes)
{
- ASSERT_NO_THROW(sc_.parseFromString("type CA"));
+ ASSERT_NO_THROW_GMX(sc_.parseFromString("type CA"));
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- EXPECT_THROW(sc_.compile(), gmx::InconsistentInputError);
+ EXPECT_THROW_GMX(sc_.compile(), gmx::InconsistentInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromMissingPDBInfo)
{
- ASSERT_NO_THROW(sc_.parseFromString("altloc A"));
+ ASSERT_NO_THROW_GMX(sc_.parseFromString("altloc A"));
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- EXPECT_THROW(sc_.compile(), gmx::InconsistentInputError);
+ EXPECT_THROW_GMX(sc_.compile(), gmx::InconsistentInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromInvalidPermutation)
{
- ASSERT_NO_THROW(sc_.parseFromString("all permute 1 1"));
+ ASSERT_NO_THROW_GMX(sc_.parseFromString("all permute 1 1"));
ASSERT_NO_FATAL_FAILURE(setAtomCount(10));
- EXPECT_THROW(sc_.compile(), gmx::InvalidInputError);
+ EXPECT_THROW_GMX(sc_.compile(), gmx::InvalidInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromInvalidPermutation2)
{
- ASSERT_NO_THROW(sc_.parseFromString("all permute 3 2 1"));
+ ASSERT_NO_THROW_GMX(sc_.parseFromString("all permute 3 2 1"));
ASSERT_NO_FATAL_FAILURE(setAtomCount(10));
- EXPECT_THROW(sc_.compile(), gmx::InconsistentInputError);
+ EXPECT_THROW_GMX(sc_.compile(), gmx::InconsistentInputError);
}
TEST_F(SelectionCollectionTest, RecoversFromInvalidPermutation3)
{
- ASSERT_NO_THROW(sc_.parseFromString("x < 1.5 permute 3 2 1"));
+ ASSERT_NO_THROW_GMX(sc_.parseFromString("x < 1.5 permute 3 2 1"));
ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));
- ASSERT_NO_THROW(sc_.compile());
- EXPECT_THROW(sc_.evaluate(frame_, NULL), gmx::InconsistentInputError);
+ ASSERT_NO_THROW_GMX(sc_.compile());
+ EXPECT_THROW_GMX(sc_.evaluate(frame_, NULL), gmx::InconsistentInputError);
}
// TODO: Tests for evaluation errors
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2010,2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2010,2011,2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "gromacs/selection/selectionoptionmanager.h"
#include "gromacs/utility/exceptions.h"
+#include "testutils/testasserts.h"
#include "testutils/testfilemanager.h"
using gmx::test::TestFileManager;
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(SelectionOption("sel").store(&sel)));
+ ASSERT_NO_THROW_GMX(options_.addOption(SelectionOption("sel").store(&sel)));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
}
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel").store(&sel).onlyStatic()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel").store(&sel).onlyStatic()));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_THROW(assigner.appendValue("resname RA RB and x < 5"), gmx::InvalidInputError);
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_THROW_GMX(assigner.appendValue("resname RA RB and x < 5"), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
}
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(SelectionOption("sel").store(&sel)));
+ ASSERT_NO_THROW_GMX(options_.addOption(SelectionOption("sel").store(&sel)));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
- EXPECT_THROW(assigner.appendValue("resname RB RC"), gmx::InvalidInputError);
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
+ EXPECT_THROW_GMX(assigner.appendValue("resname RB RC"), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
}
{
gmx::Selection sel[2];
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel").store(sel).valueCount(2)));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel").store(sel).valueCount(2)));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
- EXPECT_THROW(assigner.finishOption(), gmx::InvalidInputError);
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
+ EXPECT_THROW_GMX(assigner.finishOption(), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
}
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
- EXPECT_NO_THROW(assigner.appendValue("resname RB RC"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
- EXPECT_NO_THROW(info->setValueCount(2));
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("resname RB RC"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
+ EXPECT_NO_THROW_GMX(info->setValueCount(2));
}
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.appendValue("x < 5"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
- EXPECT_THROW(info->setOnlyStatic(true), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("x < 5"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
+ EXPECT_THROW_GMX(info->setOnlyStatic(true), gmx::InvalidInputError);
}
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
- EXPECT_NO_THROW(assigner.appendValue("resname RB RC"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
- EXPECT_THROW(info->setValueCount(1), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("resname RB RC"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
+ EXPECT_THROW_GMX(info->setValueCount(1), gmx::InvalidInputError);
}
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.appendValue("resname RA RB"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
- EXPECT_THROW(info->setValueCount(2), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
+ EXPECT_THROW_GMX(info->setValueCount(2), gmx::InvalidInputError);
}
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel").store(&sel).required()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel").store(&sel).required()));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
- ASSERT_NO_THROW(manager_.parseRequestedFromString("resname RA RB"));
+ EXPECT_NO_THROW_GMX(assigner.start());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
+ ASSERT_NO_THROW_GMX(manager_.parseRequestedFromString("resname RA RB"));
ASSERT_STREQ("resname RA RB", sel.selectionText());
}
{
gmx::Selection sel[2];
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel").store(sel).required()
- .valueCount(2)));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel").store(sel).required()
+ .valueCount(2)));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
- EXPECT_THROW(manager_.parseRequestedFromString("resname RA RB"), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.start());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
+ EXPECT_THROW_GMX(manager_.parseRequestedFromString("resname RA RB"), gmx::InvalidInputError);
}
{
gmx::Selection sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(SelectionOption("sel").store(&sel)));
+ ASSERT_NO_THROW_GMX(options_.addOption(SelectionOption("sel").store(&sel)));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
- ASSERT_NO_THROW(manager_.parseRequestedFromString("resname RA RB"));
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
+ ASSERT_NO_THROW_GMX(manager_.parseRequestedFromString("resname RA RB"));
ASSERT_STREQ("resname RA RB", sel.selectionText());
}
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
- EXPECT_NO_THROW(info->setValueCount(2));
- EXPECT_NO_THROW(manager_.parseRequestedFromString("resname RA RB; resname RB RC"));
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
+ EXPECT_NO_THROW_GMX(info->setValueCount(2));
+ EXPECT_NO_THROW_GMX(manager_.parseRequestedFromString("resname RA RB; resname RB RC"));
}
gmx::SelectionList sel;
gmx::SelectionList reqsel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel").storeVector(&sel).multiValue()));
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("reqsel").storeVector(&reqsel)
- .multiValue().required()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel").storeVector(&sel).multiValue()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("reqsel").storeVector(&reqsel)
+ .multiValue().required()));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sf"));
- EXPECT_NO_THROW(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(2U, sel.size());
gmx::SelectionList sel1;
gmx::SelectionList sel2;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel1").storeVector(&sel1).multiValue()));
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel2").storeVector(&sel2).multiValue()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel1").storeVector(&sel1).multiValue()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel2").storeVector(&sel2).multiValue()));
setManager();
gmx::OptionsAssigner assigner(&options_);
std::string value(TestFileManager::getInputFilePath("selfile.dat"));
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel1"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sf"));
- EXPECT_NO_THROW(assigner.appendValue(value));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sel2"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sf"));
- EXPECT_NO_THROW(assigner.appendValue(value));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel1"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue(value));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel2"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue(value));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(2U, sel1.size());
gmx::SelectionList sel1;
gmx::SelectionList sel2;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel1").storeVector(&sel1)));
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel2").storeVector(&sel2)));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel1").storeVector(&sel1)));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel2").storeVector(&sel2)));
setManager();
gmx::OptionsAssigner assigner(&options_);
std::string value(TestFileManager::getInputFilePath("selfile.dat"));
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel1"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sel2"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sf"));
- EXPECT_NO_THROW(assigner.appendValue(value));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel1"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel2"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue(value));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(1U, sel1.size());
gmx::SelectionList sel;
gmx::SelectionList optsel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel").storeVector(&sel)
- .multiValue().required()));
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("optsel").storeVector(&optsel)
- .multiValue()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel").storeVector(&sel)
+ .multiValue().required()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("optsel").storeVector(&optsel)
+ .multiValue()));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sf"));
- EXPECT_NO_THROW(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.startOption("optsel"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
- EXPECT_NO_THROW(manager_.parseRequestedFromString("resname RC RD"));
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.startOption("optsel"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
+ EXPECT_NO_THROW_GMX(manager_.parseRequestedFromString("resname RC RD"));
// These should match the contents of selfile.dat
ASSERT_EQ(2U, sel.size());
gmx::SelectionList sel1;
gmx::SelectionList sel2;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel1").storeVector(&sel1)
- .multiValue().required()));
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel2").storeVector(&sel2)
- .multiValue().required()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel1").storeVector(&sel1)
+ .multiValue().required()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel2").storeVector(&sel2)
+ .multiValue().required()));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- EXPECT_NO_THROW(assigner.startOption("sel1"));
- EXPECT_NO_THROW(assigner.appendValue("resname RC RD"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sf"));
- EXPECT_NO_THROW(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ EXPECT_NO_THROW_GMX(assigner.startOption("sel1"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue("resname RC RD"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(2U, sel2.size());
gmx::SelectionList sel1;
gmx::SelectionList sel2;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel1").storeVector(&sel1).required()));
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel2").storeVector(&sel2).required()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel1").storeVector(&sel1).required()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel2").storeVector(&sel2).required()));
setManager();
gmx::OptionsAssigner assigner(&options_);
std::string value(TestFileManager::getInputFilePath("selfile.dat"));
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sf"));
- EXPECT_NO_THROW(assigner.appendValue(value));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue(value));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
// These should match the contents of selfile.dat
ASSERT_EQ(1U, sel1.size());
{
gmx::SelectionList sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel").storeVector(&sel).multiValue()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel").storeVector(&sel).multiValue()));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sf"));
- EXPECT_THROW(assigner.finishOption(), gmx::InvalidInputError);
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
+ EXPECT_THROW_GMX(assigner.finishOption(), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
}
{
gmx::SelectionList sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel").storeVector(&sel).multiValue()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel").storeVector(&sel).multiValue()));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sf"));
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
// TODO: Should this be changed to an InvalidInputError?
- EXPECT_THROW(assigner.appendValue("nonexistentfile"), gmx::FileIOError);
- EXPECT_THROW(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")),
- gmx::InvalidInputError);
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_THROW_GMX(assigner.appendValue("nonexistentfile"), gmx::FileIOError);
+ EXPECT_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")),
+ gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
}
{
gmx::SelectionList sel;
using gmx::SelectionOption;
- ASSERT_NO_THROW(options_.addOption(
- SelectionOption("sel").storeVector(&sel).multiValue()));
+ ASSERT_NO_THROW_GMX(options_.addOption(
+ SelectionOption("sel").storeVector(&sel).multiValue()));
setManager();
gmx::OptionsAssigner assigner(&options_);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("sel"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("sf"));
- EXPECT_NO_THROW(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
- EXPECT_THROW(assigner.appendValue("nonexistentfile"), gmx::InvalidInputError);
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options_.finish());
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
+ EXPECT_NO_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
+ EXPECT_THROW_GMX(assigner.appendValue("nonexistentfile"), gmx::InvalidInputError);
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options_.finish());
}
} // namespace
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "testutils/cmdlinetest.h"
#include "testutils/datatest.h"
#include "testutils/refdata.h"
+#include "testutils/testasserts.h"
#include "testutils/testfilemanager.h"
namespace gmx
TrajectoryAnalysisCommandLineRunner runner(&module);
runner.setPrintCopyright(false);
int rc = 0;
- EXPECT_NO_THROW(rc = runner.run(impl_->cmdline_.argc(), impl_->cmdline_.argv()));
+ EXPECT_NO_THROW_GMX(rc = runner.run(impl_->cmdline_.argc(), impl_->cmdline_.argv()));
EXPECT_EQ(0, rc);
if (!impl_->outputFiles_.empty())
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2011,2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "gromacs/legacyheaders/thread_mpi/system_error.h"
#include "gromacs/utility/errorcodes.h"
#include "gromacs/utility/gmxassert.h"
+#include "gromacs/utility/stringutil.h"
#include "errorformat.h"
internal::printFatalErrorFooter(fp);
}
+std::string formatException(const std::exception &ex)
+{
+ // TODO: It would be nicer to not duplicate the logic from
+ // printExceptionMessage().
+ const boost::exception *boostEx = dynamic_cast<const boost::exception *>(&ex);
+ if (boostEx != NULL)
+ {
+ const char *const *funcPtr =
+ boost::get_error_info<boost::throw_function>(*boostEx);
+ const char *const *filePtr =
+ boost::get_error_info<boost::throw_file>(*boostEx);
+ const int *linePtr =
+ boost::get_error_info<boost::throw_line>(*boostEx);
+
+ std::string result;
+ if (filePtr != NULL && linePtr != NULL)
+ {
+ result = formatString("%s:%d: %s\n", *filePtr, *linePtr,
+ funcPtr != NULL ? *funcPtr : "");
+ }
+
+ // TODO: Remove duplicate context if present in multiple nested exceptions.
+ const ErrorMessage *msg =
+ boost::get_error_info<errinfo_message>(*boostEx);
+ if (msg != NULL)
+ {
+ while (msg != NULL && msg->isContext())
+ {
+ result.append(msg->text());
+ result.append("\n");
+ msg = &msg->child();
+ }
+ if (msg != NULL && !msg->text().empty())
+ {
+ result.append(msg->text());
+ result.append("\n");
+ }
+ }
+ else
+ {
+ result.append(ex.what());
+ result.append("\n");
+ }
+
+ const int *errorNumber
+ = boost::get_error_info<boost::errinfo_errno>(*boostEx);
+ if (errorNumber != NULL)
+ {
+ result.append(formatString("Reason: %s\n",
+ std::strerror(*errorNumber)));
+ const char * const *funcName
+ = boost::get_error_info<boost::errinfo_api_function>(*boostEx);
+ if (funcName != NULL)
+ {
+ result.append(formatString("(call to %s() returned error code %d)\n",
+ *funcName, *errorNumber));
+ }
+ }
+
+ // TODO: Treat also boost::nested_exception (not currently used, though)
+
+ const internal::NestedExceptionList *nested
+ = boost::get_error_info<errinfo_nested_exceptions>(*boostEx);
+ if (nested != NULL)
+ {
+ internal::NestedExceptionList::const_iterator ni;
+ for (ni = nested->begin(); ni != nested->end(); ++ni)
+ {
+ try
+ {
+ rethrow_exception(*ni);
+ }
+ catch (const std::exception &nestedEx)
+ {
+ result.append(formatException(nestedEx));
+ result.append("\n");
+ }
+ }
+ }
+ // Remove terminating line feed.
+ if (result.size() > 0U)
+ {
+ result.erase(result.size() - 1);
+ }
+ return result;
+ }
+ else
+ {
+ return ex.what();
+ }
+}
+
} // namespace gmx
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2011,2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
/*! \brief
* Formats a standard fatal error message for reporting an exception.
*
+ * \param[in] fp File to format the message to.
+ * \param[in] ex Exception to format.
+ *
* Does not throw. If memory allocation fails or some other error occurs
* while formatting the error, tries to print a reasonable alternative message.
*
* \endcode
*/
void printFatalErrorMessage(FILE *fp, const std::exception &ex);
+/*! \brief
+ * Formats an error message for reporting an exception.
+ *
+ * \param[in] ex Exception to format.
+ * \returns Formatted string containing details of \p ex.
+ * \throws std::bad_alloc if out of memory.
+ *
+ * Currently, the output format is useful mainly for tests and debugging
+ * purposes; additional flags for controlling the format can be added if other
+ * uses for the function arise.
+ */
+std::string formatException(const std::exception &ex);
/*! \brief
* Converts an exception into a return code.
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2011,2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include "testutils/datatest.h"
#include "testutils/refdata.h"
+#include "testutils/testasserts.h"
namespace gmx
{
{
int index = frameIndex_ - past;
SCOPED_TRACE(formatString("Checking storage of frame %d", index));
- ASSERT_NO_THROW({
- AnalysisDataFrameRef frame = source_->getDataFrame(index);
- ASSERT_TRUE(frame.isValid());
- checkFrame(frame, data_->frame(index));
- });
+ ASSERT_NO_THROW_GMX({
+ AnalysisDataFrameRef frame = source_->getDataFrame(index);
+ ASSERT_TRUE(frame.isValid());
+ checkFrame(frame, data_->frame(index));
+ });
}
}
--- /dev/null
+/*
+ * This file is part of the GROMACS molecular simulation package.
+ *
+ * Copyright (c) 2013, by the GROMACS development team, led by
+ * David van der Spoel, Berk Hess, Erik Lindahl, and including many
+ * others, as listed in the AUTHORS file in the top-level source
+ * directory and at http://www.gromacs.org.
+ *
+ * GROMACS is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * of the License, or (at your option) any later version.
+ *
+ * GROMACS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with GROMACS; if not, see
+ * http://www.gnu.org/licenses, or write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * If you want to redistribute modifications to GROMACS, please
+ * consider that scientific software is very special. Version
+ * control is crucial - bugs must be traceable. We will be happy to
+ * consider code for inclusion in the official distribution, but
+ * derived work must not be called official GROMACS. Details are found
+ * in the README & COPYING files - if they are missing, get the
+ * official version at http://www.gromacs.org.
+ *
+ * To help us fund GROMACS development, we humbly ask that you cite
+ * the research papers on the package. Check out http://www.gromacs.org.
+ */
+/*! \libinternal \file
+ * \brief
+ * Improved exception assertions for unit tests.
+ *
+ * This file provides assert macros to replace (ASSERT|EXPECT)(_NO)?_THROW
+ * from Google Test. They behave otherwise the same as the Google Test ones,
+ * but also print details of any unexpected exceptions. This makes it much
+ * easier to see at one glance what went wrong.
+ *
+ * \if internal
+ * \todo
+ * The implementation is somewhat ugly, and accesses some Google Test
+ * internals. Could be nice to clean it up a bit.
+ * \endif
+ *
+ * \author Teemu Murtola <teemu.murtola@gmail.com>
+ * \inlibraryapi
+ * \ingroup module_testutils
+ */
+#ifndef GMX_TESTUTILS_TESTASSERTS_H
+#define GMX_TESTUTILS_TESTASSERTS_H
+
+#include <gtest/gtest.h>
+
+#include "gromacs/utility/exceptions.h"
+
+/*! \cond internal */
+/*! \internal
+ * \brief
+ * Internal implementation macro for exception assertations.
+ *
+ * \param statement Statements to execute.
+ * \param expected_exception Exception type that \p statement should throw.
+ * \param fail Function/macro to call on failure.
+ *
+ * The implementation is copied and adjusted from
+ * include/gtest/internal/gtest-internal.h in Google Test 1.6.0.
+ */
+#define GMX_TEST_THROW_(statement, expected_exception, fail) \
+ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+ if (::testing::AssertionResult gmx_ar = ::testing::AssertionSuccess()) { \
+ bool gmx_caught_expected = false; \
+ try { \
+ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+ } \
+ catch (expected_exception const &) { \
+ gmx_caught_expected = true; \
+ } \
+ catch (std::exception const &ex) { \
+ gmx_ar << "Expected: " #statement " throws an exception of type " \
+ << #expected_exception ".\n Actual: it throws a different type.\n" \
+ << "Exception details:\n" << ::gmx::formatException(ex); \
+ goto GTEST_CONCAT_TOKEN_(gmx_label_testthrow_, __LINE__); \
+ } \
+ catch (...) { \
+ gmx_ar << "Expected: " #statement " throws an exception of type " \
+ << #expected_exception ".\n Actual: it throws a different type."; \
+ goto GTEST_CONCAT_TOKEN_(gmx_label_testthrow_, __LINE__); \
+ } \
+ if (!gmx_caught_expected) { \
+ gmx_ar << "Expected: " #statement " throws an exception of type " \
+ << #expected_exception ".\n Actual: it throws nothing."; \
+ goto GTEST_CONCAT_TOKEN_(gmx_label_testthrow_, __LINE__); \
+ } \
+ } else \
+ GTEST_CONCAT_TOKEN_(gmx_label_testthrow_, __LINE__) : \
+ fail(gmx_ar.message())
+
+/*! \internal
+ * \brief
+ * Internal implementation macro for exception assertations.
+ *
+ * \param statement Statements to execute.
+ * \param fail Function/macro to call on failure.
+ *
+ * The implementation is copied and adjusted from
+ * include/gtest/internal/gtest-internal.h in Google Test 1.6.0.
+ */
+#define GMX_TEST_NO_THROW_(statement, fail) \
+ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+ if (::testing::AssertionResult gmx_ar = ::testing::AssertionSuccess()) { \
+ try { \
+ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+ } \
+ catch (std::exception const &ex) { \
+ gmx_ar << "Expected: " #statement " doesn't throw an exception.\n" \
+ << " Actual: it throws.\n" \
+ << "Exception details:\n" << ::gmx::formatException(ex); \
+ goto GTEST_CONCAT_TOKEN_(gmx_label_testnothrow_, __LINE__); \
+ } \
+ catch (...) { \
+ gmx_ar << "Expected: " #statement " doesn't throw an exception.\n" \
+ << " Actual: it throws."; \
+ goto GTEST_CONCAT_TOKEN_(gmx_label_testnothrow_, __LINE__); \
+ } \
+ } else \
+ GTEST_CONCAT_TOKEN_(gmx_label_testnothrow_, __LINE__) : \
+ fail(gmx_ar.message())
+//! \endcond
+
+/*! \brief
+ * Asserts that a statement throws a given exception.
+ *
+ * See Google Test documentation on EXPECT_THROW.
+ * This macro works the same, but additionally prints details of unexpected
+ * exceptions.
+ */
+#define EXPECT_THROW_GMX(statement, expected_exception) \
+ GMX_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
+/*! \brief
+ * Asserts that a statement does not throw.
+ *
+ * See Google Test documentation on EXPECT_NO_THROW.
+ * This macro works the same, but additionally prints details of unexpected
+ * exceptions.
+ */
+#define EXPECT_NO_THROW_GMX(statement) \
+ GMX_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+/*! \brief
+ * Asserts that a statement throws a given exception.
+ *
+ * See Google Test documentation on ASSERT_THROW.
+ * This macro works the same, but additionally prints details of unexpected
+ * exceptions.
+ */
+#define ASSERT_THROW_GMX(statement, expected_exception) \
+ GMX_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
+/*! \brief
+ * Asserts that a statement does not throw.
+ *
+ * See Google Test documentation on ASSERT_NO_THROW.
+ * This macro works the same, but additionally prints details of unexpected
+ * exceptions.
+ */
+#define ASSERT_NO_THROW_GMX(statement) \
+ GMX_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
+
+#endif
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff