src/gromacs/analysisdata/tests/histogram.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2012,2013,2014, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source 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 "gromacs/analysisdata/tests/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 #ifndef STATIC_ANON_NAMESPACE_BUG
 161             static SimpleInputData singleton;
 162             return singleton.data_;
 163 #else
 164             static SimpleInputData singleton_histogram;
 165             return singleton_histogram.data_;
 166 #endif
 167         }
 168
 169         SimpleInputData() : data_(1, true)
 170         {
 171             using gmx::test::AnalysisDataTestInputFrame;
 172             data_.setColumnCount(0, 1);
 173             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 174             frame1.addPointSetWithValues(0, 0, 0.7);
 175             frame1.addPointSetWithValues(0, 0, 1.1);
 176             frame1.addPointSetWithValues(0, 0, 2.3);
 177             frame1.addPointSetWithValues(0, 0, 2.9);
 178             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 179             frame2.addPointSetWithValues(0, 0, 1.3);
 180             frame2.addPointSetWithValues(0, 0, 2.2);
 181             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 182             frame3.addPointSetWithValues(0, 0, 3.3);
 183             frame3.addPointSetWithValues(0, 0, 1.2);
 184             frame3.addPointSetWithValues(0, 0, 1.3);
 185         }
 186
 187     private:
 188         AnalysisDataTestInput  data_;
 189 };
 190
 191 TEST_F(SimpleHistogramModuleTest, ComputesCorrectly)
 192 {
 193     const AnalysisDataTestInput &input = SimpleInputData::get();
 194     gmx::AnalysisData            data;
 195     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 196
 197     gmx::AnalysisDataSimpleHistogramModulePointer module(
 198             new gmx::AnalysisDataSimpleHistogramModule(
 199                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 200     data.addModule(module);
 201
 202     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 203     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 204     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 205     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 206                                                   &module->averager()));
 207     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 208     ASSERT_NO_THROW_GMX(module->averager().done());
 209 }
 210
 211
 212 TEST_F(SimpleHistogramModuleTest, ComputesCorrectlyWithAll)
 213 {
 214     const AnalysisDataTestInput &input = SimpleInputData::get();
 215     gmx::AnalysisData            data;
 216     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 217
 218     gmx::AnalysisDataSimpleHistogramModulePointer module(
 219             new gmx::AnalysisDataSimpleHistogramModule(
 220                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 221     data.addModule(module);
 222
 223     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 224     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 225     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 226     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 227                                                   &module->averager()));
 228     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 229     ASSERT_NO_THROW_GMX(module->averager().done());
 230 }
 231
 232
 233 /********************************************************************
 234  * Tests for gmx::AnalysisDataWeightedHistogramModule.
 235  */
 236
 237 //! Test fixture for gmx::AnalysisDataWeightedHistogramModule.
 238 typedef gmx::test::AnalysisDataTestFixture WeightedHistogramModuleTest;
 239
 240 // Input data for both weighted histogram and bin average module tests.
 241 class WeightedSimpleInputData
 242 {
 243     public:
 244         static const AnalysisDataTestInput &get()
 245         {
 246 #ifndef STATIC_ANON_NAMESPACE_BUG
 247             static WeightedSimpleInputData singleton;
 248             return singleton.data_;
 249 #else
 250             static WeightedSimpleInputData singleton_histogram;
 251             return singleton_histogram.data_;
 252 #endif
 253         }
 254
 255         WeightedSimpleInputData() : data_(1, true)
 256         {
 257             using gmx::test::AnalysisDataTestInputFrame;
 258             data_.setColumnCount(0, 2);
 259             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 260             frame1.addPointSetWithValues(0, 0, 0.7, 0.5);
 261             frame1.addPointSetWithValues(0, 0, 1.1, 1.0);
 262             frame1.addPointSetWithValues(0, 0, 2.3, 1.0);
 263             frame1.addPointSetWithValues(0, 0, 2.9, 2.0);
 264             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 265             frame2.addPointSetWithValues(0, 0, 1.3, 1.0);
 266             frame2.addPointSetWithValues(0, 0, 2.2, 3.0);
 267             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 268             frame3.addPointSetWithValues(0, 0, 3.3, 0.5);
 269             frame3.addPointSetWithValues(0, 0, 1.2, 2.0);
 270             frame3.addPointSetWithValues(0, 0, 1.3, 1.0);
 271         }
 272
 273     private:
 274         AnalysisDataTestInput  data_;
 275 };
 276
 277 // Input data for both weighted histogram and bin average module tests.
 278 class WeightedDataSetInputData
 279 {
 280     public:
 281         static const AnalysisDataTestInput &get()
 282         {
 283 #ifndef STATIC_ANON_NAMESPACE_BUG
 284             static WeightedDataSetInputData singleton;
 285             return singleton.data_;
 286 #else
 287             static WeightedDataSetInputData singleton_histogram;
 288             return singleton_histogram.data_;
 289 #endif
 290         }
 291
 292         WeightedDataSetInputData() : data_(2, true)
 293         {
 294             using gmx::test::AnalysisDataTestInputFrame;
 295             data_.setColumnCount(0, 2);
 296             data_.setColumnCount(1, 2);
 297             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 298             frame1.addPointSetWithValues(0, 0, 0.7, 0.5);
 299             frame1.addPointSetWithValues(0, 0, 1.1, 1.0);
 300             frame1.addPointSetWithValues(1, 0, 2.3, 1.0);
 301             frame1.addPointSetWithValues(1, 0, 2.9, 2.0);
 302             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 303             frame2.addPointSetWithValues(0, 0, 1.3, 1.0);
 304             frame2.addPointSetWithValues(1, 0, 2.2, 3.0);
 305             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 306             frame3.addPointSetWithValues(0, 0, 3.3, 0.5);
 307             frame3.addPointSetWithValues(0, 0, 1.2, 2.0);
 308             frame3.addPointSetWithValues(1, 0, 1.3, 1.0);
 309         }
 310
 311     private:
 312         AnalysisDataTestInput  data_;
 313 };
 314
 315 TEST_F(WeightedHistogramModuleTest, ComputesCorrectly)
 316 {
 317     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 318     gmx::AnalysisData            data;
 319     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 320
 321     gmx::AnalysisDataWeightedHistogramModulePointer module(
 322             new gmx::AnalysisDataWeightedHistogramModule(
 323                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 324     data.addModule(module);
 325
 326     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 327     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 328     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 329     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 330                                                   &module->averager()));
 331     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 332     ASSERT_NO_THROW_GMX(module->averager().done());
 333 }
 334
 335
 336 TEST_F(WeightedHistogramModuleTest, ComputesCorrectlyWithAll)
 337 {
 338     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 339     gmx::AnalysisData            data;
 340     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 341
 342     gmx::AnalysisDataWeightedHistogramModulePointer module(
 343             new gmx::AnalysisDataWeightedHistogramModule(
 344                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 345     data.addModule(module);
 346
 347     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 348     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 349     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 350     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 351                                                   &module->averager()));
 352     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 353     ASSERT_NO_THROW_GMX(module->averager().done());
 354 }
 355
 356
 357 TEST_F(WeightedHistogramModuleTest, HandlesMultipleDataSets)
 358 {
 359     const AnalysisDataTestInput &input = WeightedDataSetInputData::get();
 360     gmx::AnalysisData            data;
 361     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 362
 363     gmx::AnalysisDataWeightedHistogramModulePointer module(
 364             new gmx::AnalysisDataWeightedHistogramModule(
 365                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 366     data.addModule(module);
 367
 368     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 369     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 370     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 371     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 372                                                   &module->averager()));
 373     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 374     ASSERT_NO_THROW_GMX(module->averager().done());
 375 }
 376
 377
 378 /********************************************************************
 379  * Tests for gmx::AnalysisDataBinAverageModule.
 380  */
 381
 382 //! Test fixture for gmx::AnalysisDataBinAverageModule.
 383 typedef gmx::test::AnalysisDataTestFixture BinAverageModuleTest;
 384
 385 TEST_F(BinAverageModuleTest, ComputesCorrectly)
 386 {
 387     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 388     gmx::AnalysisData            data;
 389     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 390
 391     gmx::AnalysisDataBinAverageModulePointer module(
 392             new gmx::AnalysisDataBinAverageModule(
 393                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 394     data.addModule(module);
 395
 396     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 397     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 398     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 399     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 400 }
 401
 402
 403 TEST_F(BinAverageModuleTest, ComputesCorrectlyWithAll)
 404 {
 405     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 406     gmx::AnalysisData            data;
 407     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 408
 409     gmx::AnalysisDataBinAverageModulePointer module(
 410             new gmx::AnalysisDataBinAverageModule(
 411                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 412     data.addModule(module);
 413
 414     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 415     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 416     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 417     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 418 }
 419
 420
 421 TEST_F(BinAverageModuleTest, HandlesMultipleDataSets)
 422 {
 423     const AnalysisDataTestInput &input = WeightedDataSetInputData::get();
 424     gmx::AnalysisData            data;
 425     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 426
 427     gmx::AnalysisDataBinAverageModulePointer module(
 428             new gmx::AnalysisDataBinAverageModule(
 429                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 430     data.addModule(module);
 431
 432     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 433     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 434     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 435     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 436 }
 437
 438
 439 /********************************************************************
 440  * Tests for gmx::AbstractAverageHistogram.
 441  *
 442  * This class derives from gmx::AbstractAnalysisArrayData, and is tested using
 443  * corresponding facilities in gmx::test::AnalysisDataTestFixture.
 444  */
 445
 446 //! Test fixture for gmx::AbstractAverageHistogram.
 447 typedef gmx::test::AnalysisDataTestFixture AbstractAverageHistogramTest;
 448
 449 // Input data for gmx::AbstractAverageHistogram tests.
 450 class AverageInputData
 451 {
 452     public:
 453         static const AnalysisDataTestInput &get()
 454         {
 455 #ifndef STATIC_ANON_NAMESPACE_BUG
 456             static AverageInputData singleton;
 457             return singleton.data_;
 458 #else
 459             static AverageInputData singleton_histogram;
 460             return singleton_histogram.data_;
 461 #endif
 462         }
 463
 464         AverageInputData() : data_(1, false)
 465         {
 466             data_.setColumnCount(0, 1);
 467             data_.addFrameWithValueAndError(1.0,  2.0, 1.0);
 468             data_.addFrameWithValueAndError(1.5,  1.0, 1.0);
 469             data_.addFrameWithValueAndError(2.0,  3.0, 2.0);
 470             data_.addFrameWithValueAndError(2.5,  4.0, 2.0);
 471             data_.addFrameWithValueAndError(3.0,  2.0, 1.0);
 472             data_.addFrameWithValueAndError(3.5,  0.0, 3.0);
 473             data_.addFrameWithValueAndError(4.0,  1.0, 3.0);
 474         }
 475
 476     private:
 477         AnalysisDataTestInput  data_;
 478 };
 479
 480 /*! \brief
 481  * Mock object for testing gmx::AbstractAverageHistogram.
 482  *
 483  * Exposes necessary methods from gmx::AbstractAverageHistogram to use with
 484  * gmx::test::AnalysisDataTestFixture::setupArrayData().
 485  *
 486  * \ingroup module_analysisdata
 487  */
 488 class MockAverageHistogram : public gmx::AbstractAverageHistogram
 489 {
 490     public:
 491         //! Creates a histogram module with defined bin parameters.
 492         explicit MockAverageHistogram(const gmx::AnalysisHistogramSettings &settings)
 493             : AbstractAverageHistogram(settings)
 494         {
 495         }
 496
 497         using AbstractAverageHistogram::init;
 498         using AbstractAverageHistogram::setColumnCount;
 499         using AbstractAverageHistogram::setRowCount;
 500         using AbstractAverageHistogram::allocateValues;
 501         using AbstractAverageHistogram::value;
 502 };
 503
 504
 505 TEST_F(AbstractAverageHistogramTest, ClonesCorrectly)
 506 {
 507     const AnalysisDataTestInput &input = AverageInputData::get();
 508     MockAverageHistogram         data(
 509             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 510     setupArrayData(input, &data);
 511
 512     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 513     gmx::AverageHistogramPointer copy(data.clone());
 514     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy.get()));
 515     ASSERT_NO_THROW_GMX(copy->done());
 516     ASSERT_NO_THROW_GMX(data.done());
 517     gmx::AverageHistogramPointer copy2(data.clone());
 518     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy2.get()));
 519     ASSERT_NO_THROW_GMX(copy2->done());
 520 }
 521
 522
 523 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidth)
 524 {
 525     const AnalysisDataTestInput &input = AverageInputData::get();
 526     MockAverageHistogram         data(
 527             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 528     setupArrayData(input, &data);
 529
 530     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 531     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 532     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
 533     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 534     ASSERT_NO_THROW_GMX(data.done());
 535     ASSERT_NO_THROW_GMX(resampled->done());
 536 }
 537
 538
 539 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidthWithIntegerBins)
 540 {
 541     const AnalysisDataTestInput &input = AverageInputData::get();
 542     MockAverageHistogram         data(
 543             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 544     setupArrayData(input, &data);
 545
 546     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 547     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 548     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
 549     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 550     ASSERT_NO_THROW_GMX(data.done());
 551     ASSERT_NO_THROW_GMX(resampled->done());
 552 }
 553
 554 } // namespace