src/gromacs/analysisdata/tests/histogram.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2012,2013, by the GROMACS development team, led by
   5  * David van der Spoel, Berk Hess, Erik Lindahl, and including many
   6  * others, as listed in the AUTHORS file in the top-level source
   7  * directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Tests for functionality of analysis data histogram modules.
  38  *
  39  * These tests check that classes in histogram.h compute histograms correctly
  40  * with simple input data.  Also different ways of initializing the histograms
  41  * are tested.
  42  * Checking is done using gmx::test::AnalysisDataTestFixture and reference
  43  * data.  Also the input data is written to the reference data to catch
  44  * out-of-date reference.
  45  *
  46  * \author Teemu Murtola <teemu.murtola@gmail.com>
  47  * \ingroup module_analysisdata
  48  */
  49 #include <gtest/gtest.h>
  50
  51 #include "gromacs/analysisdata/analysisdata.h"
  52 #include "gromacs/analysisdata/modules/histogram.h"
  53
  54 #include "testutils/datatest.h"
  55 #include "testutils/testasserts.h"
  56
  57 using gmx::test::AnalysisDataTestInput;
  58
  59 namespace
  60 {
  61
  62 /********************************************************************
  63  * Tests for gmx::AnalysisHistogramSettings.
  64  *
  65  * These tests check that gmx::AnalysisHistogramSettings objects can be
  66  * initialized from various types of values, and that the bin positions are
  67  * computed correctly based on the input values.
  68  */
  69
  70 TEST(AnalysisHistogramSettingsTest, InitializesFromBins)
  71 {
  72     gmx::AnalysisHistogramSettings settings(
  73             gmx::histogramFromBins(1.0, 5, 0.5));
  74     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
  75     EXPECT_EQ(5, settings.binCount());
  76     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
  77     EXPECT_FLOAT_EQ(3.5, settings.lastEdge());
  78 }
  79
  80
  81 TEST(AnalysisHistogramSettingsTest, InitializesFromBinsWithIntegerBins)
  82 {
  83     gmx::AnalysisHistogramSettings settings(
  84             gmx::histogramFromBins(1.0, 5, 0.5).integerBins());
  85     EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
  86     EXPECT_EQ(5, settings.binCount());
  87     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
  88     EXPECT_FLOAT_EQ(3.25, settings.lastEdge());
  89 }
  90
  91
  92 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCount)
  93 {
  94     gmx::AnalysisHistogramSettings settings(
  95             gmx::histogramFromRange(1.0, 4.0).binCount(6));
  96     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
  97     EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
  98     EXPECT_EQ(6, settings.binCount());
  99     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 100 }
 101
 102
 103 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidth)
 104 {
 105     gmx::AnalysisHistogramSettings settings(
 106             gmx::histogramFromRange(1.0, 4.0).binWidth(0.5));
 107     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
 108     EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
 109     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 110     EXPECT_EQ(6, settings.binCount());
 111 }
 112
 113
 114 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCountAndIntegerBins)
 115 {
 116     gmx::AnalysisHistogramSettings settings(
 117             gmx::histogramFromRange(1.0, 4.0).binCount(7).integerBins());
 118     EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
 119     EXPECT_FLOAT_EQ(4.25, settings.lastEdge());
 120     EXPECT_EQ(7, settings.binCount());
 121     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 122 }
 123
 124
 125 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidthAndIntegerBins)
 126 {
 127     gmx::AnalysisHistogramSettings settings(
 128             gmx::histogramFromRange(1.0, 4.0).binWidth(0.5).integerBins());
 129     EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
 130     EXPECT_FLOAT_EQ(4.25, settings.lastEdge());
 131     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 132     EXPECT_EQ(7, settings.binCount());
 133 }
 134
 135
 136 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithRoundedRange)
 137 {
 138     gmx::AnalysisHistogramSettings settings(
 139             gmx::histogramFromRange(1.2, 3.8).binWidth(0.5).roundRange());
 140     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
 141     EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
 142     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 143     EXPECT_EQ(6, settings.binCount());
 144 }
 145
 146
 147 /********************************************************************
 148  * Tests for gmx::AnalysisDataSimpleHistogramModule.
 149  */
 150
 151 //! Test fixture for gmx::AnalysisDataSimpleHistogramModule.
 152 typedef gmx::test::AnalysisDataTestFixture SimpleHistogramModuleTest;
 153
 154 // Input data for gmx::AnalysisDataSimpleHistogramModule tests.
 155 class SimpleInputData
 156 {
 157     public:
 158         static const AnalysisDataTestInput &get()
 159         {
 160             static SimpleInputData singleton;
 161             return singleton.data_;
 162         }
 163
 164         SimpleInputData() : data_(1, true)
 165         {
 166             using gmx::test::AnalysisDataTestInputFrame;
 167             data_.setColumnCount(0, 1);
 168             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 169             frame1.addPointSetWithValues(0, 0, 0.7);
 170             frame1.addPointSetWithValues(0, 0, 1.1);
 171             frame1.addPointSetWithValues(0, 0, 2.3);
 172             frame1.addPointSetWithValues(0, 0, 2.9);
 173             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 174             frame2.addPointSetWithValues(0, 0, 1.3);
 175             frame2.addPointSetWithValues(0, 0, 2.2);
 176             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 177             frame3.addPointSetWithValues(0, 0, 3.3);
 178             frame3.addPointSetWithValues(0, 0, 1.2);
 179             frame3.addPointSetWithValues(0, 0, 1.3);
 180         }
 181
 182     private:
 183         AnalysisDataTestInput  data_;
 184 };
 185
 186 TEST_F(SimpleHistogramModuleTest, ComputesCorrectly)
 187 {
 188     const AnalysisDataTestInput &input = SimpleInputData::get();
 189     gmx::AnalysisData            data;
 190     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 191
 192     gmx::AnalysisDataSimpleHistogramModulePointer module(
 193             new gmx::AnalysisDataSimpleHistogramModule(
 194                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 195     data.addModule(module);
 196
 197     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 198     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 199     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 200     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 201                                                   &module->averager()));
 202     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 203     ASSERT_NO_THROW_GMX(module->averager().done());
 204 }
 205
 206
 207 TEST_F(SimpleHistogramModuleTest, ComputesCorrectlyWithAll)
 208 {
 209     const AnalysisDataTestInput &input = SimpleInputData::get();
 210     gmx::AnalysisData            data;
 211     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 212
 213     gmx::AnalysisDataSimpleHistogramModulePointer module(
 214             new gmx::AnalysisDataSimpleHistogramModule(
 215                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 216     data.addModule(module);
 217
 218     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 219     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 220     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 221     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 222                                                   &module->averager()));
 223     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 224     ASSERT_NO_THROW_GMX(module->averager().done());
 225 }
 226
 227
 228 /********************************************************************
 229  * Tests for gmx::AnalysisDataWeightedHistogramModule.
 230  */
 231
 232 //! Test fixture for gmx::AnalysisDataWeightedHistogramModule.
 233 typedef gmx::test::AnalysisDataTestFixture WeightedHistogramModuleTest;
 234
 235 // Input data for both weighted histogram and bin average module tests.
 236 class WeightedSimpleInputData
 237 {
 238     public:
 239         static const AnalysisDataTestInput &get()
 240         {
 241             static WeightedSimpleInputData singleton;
 242             return singleton.data_;
 243         }
 244
 245         WeightedSimpleInputData() : data_(1, true)
 246         {
 247             using gmx::test::AnalysisDataTestInputFrame;
 248             data_.setColumnCount(0, 2);
 249             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 250             frame1.addPointSetWithValues(0, 0, 0.7, 0.5);
 251             frame1.addPointSetWithValues(0, 0, 1.1, 1.0);
 252             frame1.addPointSetWithValues(0, 0, 2.3, 1.0);
 253             frame1.addPointSetWithValues(0, 0, 2.9, 2.0);
 254             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 255             frame2.addPointSetWithValues(0, 0, 1.3, 1.0);
 256             frame2.addPointSetWithValues(0, 0, 2.2, 3.0);
 257             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 258             frame3.addPointSetWithValues(0, 0, 3.3, 0.5);
 259             frame3.addPointSetWithValues(0, 0, 1.2, 2.0);
 260             frame3.addPointSetWithValues(0, 0, 1.3, 1.0);
 261         }
 262
 263     private:
 264         AnalysisDataTestInput  data_;
 265 };
 266
 267 // Input data for both weighted histogram and bin average module tests.
 268 class WeightedDataSetInputData
 269 {
 270     public:
 271         static const AnalysisDataTestInput &get()
 272         {
 273             static WeightedDataSetInputData singleton;
 274             return singleton.data_;
 275         }
 276
 277         WeightedDataSetInputData() : data_(2, true)
 278         {
 279             using gmx::test::AnalysisDataTestInputFrame;
 280             data_.setColumnCount(0, 2);
 281             data_.setColumnCount(1, 2);
 282             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 283             frame1.addPointSetWithValues(0, 0, 0.7, 0.5);
 284             frame1.addPointSetWithValues(0, 0, 1.1, 1.0);
 285             frame1.addPointSetWithValues(1, 0, 2.3, 1.0);
 286             frame1.addPointSetWithValues(1, 0, 2.9, 2.0);
 287             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 288             frame2.addPointSetWithValues(0, 0, 1.3, 1.0);
 289             frame2.addPointSetWithValues(1, 0, 2.2, 3.0);
 290             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 291             frame3.addPointSetWithValues(0, 0, 3.3, 0.5);
 292             frame3.addPointSetWithValues(0, 0, 1.2, 2.0);
 293             frame3.addPointSetWithValues(1, 0, 1.3, 1.0);
 294         }
 295
 296     private:
 297         AnalysisDataTestInput  data_;
 298 };
 299
 300 TEST_F(WeightedHistogramModuleTest, ComputesCorrectly)
 301 {
 302     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 303     gmx::AnalysisData            data;
 304     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 305
 306     gmx::AnalysisDataWeightedHistogramModulePointer module(
 307             new gmx::AnalysisDataWeightedHistogramModule(
 308                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 309     data.addModule(module);
 310
 311     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 312     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 313     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 314     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 315                                                   &module->averager()));
 316     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 317     ASSERT_NO_THROW_GMX(module->averager().done());
 318 }
 319
 320
 321 TEST_F(WeightedHistogramModuleTest, ComputesCorrectlyWithAll)
 322 {
 323     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 324     gmx::AnalysisData            data;
 325     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 326
 327     gmx::AnalysisDataWeightedHistogramModulePointer module(
 328             new gmx::AnalysisDataWeightedHistogramModule(
 329                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 330     data.addModule(module);
 331
 332     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 333     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 334     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 335     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 336                                                   &module->averager()));
 337     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 338     ASSERT_NO_THROW_GMX(module->averager().done());
 339 }
 340
 341
 342 TEST_F(WeightedHistogramModuleTest, HandlesMultipleDataSets)
 343 {
 344     const AnalysisDataTestInput &input = WeightedDataSetInputData::get();
 345     gmx::AnalysisData            data;
 346     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 347
 348     gmx::AnalysisDataWeightedHistogramModulePointer module(
 349             new gmx::AnalysisDataWeightedHistogramModule(
 350                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 351     data.addModule(module);
 352
 353     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 354     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 355     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 356     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 357                                                   &module->averager()));
 358     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 359     ASSERT_NO_THROW_GMX(module->averager().done());
 360 }
 361
 362
 363 /********************************************************************
 364  * Tests for gmx::AnalysisDataBinAverageModule.
 365  */
 366
 367 //! Test fixture for gmx::AnalysisDataBinAverageModule.
 368 typedef gmx::test::AnalysisDataTestFixture BinAverageModuleTest;
 369
 370 TEST_F(BinAverageModuleTest, ComputesCorrectly)
 371 {
 372     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 373     gmx::AnalysisData            data;
 374     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 375
 376     gmx::AnalysisDataBinAverageModulePointer module(
 377             new gmx::AnalysisDataBinAverageModule(
 378                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 379     data.addModule(module);
 380
 381     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 382     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 383     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 384     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 385 }
 386
 387
 388 TEST_F(BinAverageModuleTest, ComputesCorrectlyWithAll)
 389 {
 390     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 391     gmx::AnalysisData            data;
 392     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 393
 394     gmx::AnalysisDataBinAverageModulePointer module(
 395             new gmx::AnalysisDataBinAverageModule(
 396                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 397     data.addModule(module);
 398
 399     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 400     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 401     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 402     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 403 }
 404
 405
 406 TEST_F(BinAverageModuleTest, HandlesMultipleDataSets)
 407 {
 408     const AnalysisDataTestInput &input = WeightedDataSetInputData::get();
 409     gmx::AnalysisData            data;
 410     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 411
 412     gmx::AnalysisDataBinAverageModulePointer module(
 413             new gmx::AnalysisDataBinAverageModule(
 414                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 415     data.addModule(module);
 416
 417     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 418     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 419     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 420     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 421 }
 422
 423
 424 /********************************************************************
 425  * Tests for gmx::AbstractAverageHistogram.
 426  *
 427  * This class derives from gmx::AbstractAnalysisArrayData, and is tested using
 428  * corresponding facilities in gmx::test::AnalysisDataTestFixture.
 429  */
 430
 431 //! Test fixture for gmx::AbstractAverageHistogram.
 432 typedef gmx::test::AnalysisDataTestFixture AbstractAverageHistogramTest;
 433
 434 // Input data for gmx::AbstractAverageHistogram tests.
 435 class AverageInputData
 436 {
 437     public:
 438         static const AnalysisDataTestInput &get()
 439         {
 440             static AverageInputData singleton;
 441             return singleton.data_;
 442         }
 443
 444         AverageInputData() : data_(1, false)
 445         {
 446             data_.setColumnCount(0, 1);
 447             data_.addFrameWithValueAndError(1.0,  2.0, 1.0);
 448             data_.addFrameWithValueAndError(1.5,  1.0, 1.0);
 449             data_.addFrameWithValueAndError(2.0,  3.0, 2.0);
 450             data_.addFrameWithValueAndError(2.5,  4.0, 2.0);
 451             data_.addFrameWithValueAndError(3.0,  2.0, 1.0);
 452             data_.addFrameWithValueAndError(3.5,  0.0, 3.0);
 453             data_.addFrameWithValueAndError(4.0,  1.0, 3.0);
 454         }
 455
 456     private:
 457         AnalysisDataTestInput  data_;
 458 };
 459
 460 /*! \internal \brief
 461  * Mock object for testing gmx::AbstractAverageHistogram.
 462  *
 463  * Exposes necessary methods from gmx::AbstractAverageHistogram to use with
 464  * gmx::test::AnalysisDataTestFixture::setupArrayData().
 465  */
 466 class MockAverageHistogram : public gmx::AbstractAverageHistogram
 467 {
 468     public:
 469         MockAverageHistogram() {}
 470         //! Creates a histogram module with defined bin parameters.
 471         explicit MockAverageHistogram(const gmx::AnalysisHistogramSettings &settings)
 472             : AbstractAverageHistogram(settings)
 473         {
 474         }
 475
 476         using AbstractAverageHistogram::init;
 477         using AbstractAverageHistogram::setColumnCount;
 478         using AbstractAverageHistogram::setRowCount;
 479         using AbstractAverageHistogram::allocateValues;
 480         using AbstractAverageHistogram::value;
 481 };
 482
 483
 484 TEST_F(AbstractAverageHistogramTest, ClonesCorrectly)
 485 {
 486     const AnalysisDataTestInput &input = AverageInputData::get();
 487     MockAverageHistogram         data(
 488             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 489     setupArrayData(input, &data);
 490
 491     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 492     gmx::AverageHistogramPointer copy(data.clone());
 493     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy.get()));
 494     ASSERT_NO_THROW_GMX(copy->done());
 495     ASSERT_NO_THROW_GMX(data.done());
 496     gmx::AverageHistogramPointer copy2(data.clone());
 497     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy2.get()));
 498     ASSERT_NO_THROW_GMX(copy2->done());
 499 }
 500
 501
 502 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidth)
 503 {
 504     const AnalysisDataTestInput &input = AverageInputData::get();
 505     MockAverageHistogram         data(
 506             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 507     setupArrayData(input, &data);
 508
 509     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 510     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 511     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
 512     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 513     ASSERT_NO_THROW_GMX(data.done());
 514     ASSERT_NO_THROW_GMX(resampled->done());
 515 }
 516
 517
 518 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidthWithIntegerBins)
 519 {
 520     const AnalysisDataTestInput &input = AverageInputData::get();
 521     MockAverageHistogram         data(
 522             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 523     setupArrayData(input, &data);
 524
 525     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 526     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 527     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
 528     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 529     ASSERT_NO_THROW_GMX(data.done());
 530     ASSERT_NO_THROW_GMX(resampled->done());
 531 }
 532
 533 } // namespace