src/gromacs/analysisdata/tests/analysisdata.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2011,2012,2013,2014,2015,2018,2019, 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 analysis data functionality.
  38  *
  39  * These tests check the functionality of gmx::AnalysisData, as well as classes
  40  * used in its implementation: gmx::AbstractAnalysisData and
  41  * gmx::AnalysisDataStorage.
  42  * Most checking is done using gmx::test::AnalysisDataTestFixture and mock
  43  * modules that implement gmx::IAnalysisDataModule.
  44  *
  45  * \author Teemu Murtola <teemu.murtola@gmail.com>
  46  * \ingroup module_analysisdata
  47  */
  48 #include "gmxpre.h"
  49
  50 #include "gromacs/analysisdata/analysisdata.h"
  51
  52 #include <gmock/gmock.h>
  53 #include <gtest/gtest.h>
  54
  55 #include "gromacs/analysisdata/paralleloptions.h"
  56 #include "gromacs/utility/exceptions.h"
  57
  58 #include "gromacs/analysisdata/tests/datatest.h"
  59 #include "gromacs/analysisdata/tests/mock_datamodule.h"
  60 #include "testutils/testasserts.h"
  61
  62 using gmx::test::AnalysisDataTestInput;
  63 using gmx::test::MockAnalysisDataModule;
  64 using gmx::test::MockAnalysisDataModulePointer;
  65
  66 namespace
  67 {
  68
  69 /********************************************************************
  70  * Tests for gmx::AnalysisData without any actual data.
  71  */
  72
  73 /*
  74  * Tests that simple initialization works.
  75  */
  76 TEST(AnalysisDataInitializationTest, BasicInitialization)
  77 {
  78     gmx::AnalysisData data;
  79     EXPECT_EQ(1, data.dataSetCount());
  80     EXPECT_EQ(0, data.columnCount(0));
  81     EXPECT_EQ(0, data.columnCount());
  82     EXPECT_FALSE(data.isMultipoint());
  83     EXPECT_EQ(0, data.frameCount());
  84
  85     data.setColumnCount(0, 1);
  86     EXPECT_EQ(1, data.columnCount(0));
  87     EXPECT_EQ(1, data.columnCount());
  88     EXPECT_FALSE(data.isMultipoint());
  89
  90     data.setDataSetCount(2);
  91     EXPECT_EQ(2, data.dataSetCount());
  92     data.setColumnCount(0, 3);
  93     EXPECT_EQ(3, data.columnCount(0));
  94     EXPECT_EQ(0, data.columnCount(1));
  95     data.setColumnCount(1, 2);
  96     EXPECT_EQ(3, data.columnCount(0));
  97     EXPECT_EQ(2, data.columnCount(1));
  98
  99     data.setDataSetCount(1);
 100     EXPECT_EQ(1, data.dataSetCount());
 101     data.setMultipoint(true);
 102     EXPECT_EQ(3, data.columnCount());
 103     EXPECT_TRUE(data.isMultipoint());
 104
 105     data.setColumnCount(0, 1);
 106     EXPECT_EQ(1, data.columnCount());
 107     EXPECT_TRUE(data.isMultipoint());
 108 }
 109
 110 /*
 111  * Tests that checking for compatibility of modules with multicolumn data
 112  * works.
 113  */
 114 TEST(AnalysisDataInitializationTest, ChecksMultiColumnModules)
 115 {
 116     gmx::AnalysisData data;
 117     data.setColumnCount(0, 2);
 118
 119     MockAnalysisDataModulePointer mod1(new MockAnalysisDataModule(0));
 120     EXPECT_THROW_GMX(data.addModule(mod1), gmx::APIError);
 121
 122     MockAnalysisDataModulePointer mod2(
 123             new MockAnalysisDataModule(gmx::IAnalysisDataModule::efAllowMulticolumn));
 124     EXPECT_NO_THROW_GMX(data.addModule(mod2));
 125 }
 126
 127 /*
 128  * Tests that checking for compatibility of modules with multipoint data
 129  * works.
 130  */
 131 TEST(AnalysisDataInitializationTest, ChecksMultipointModules)
 132 {
 133     gmx::AnalysisData data;
 134     data.setColumnCount(0, 1);
 135     data.setMultipoint(true);
 136
 137     MockAnalysisDataModulePointer mod1(new MockAnalysisDataModule(0));
 138     EXPECT_THROW_GMX(data.addModule(mod1), gmx::APIError);
 139
 140     MockAnalysisDataModulePointer mod2(
 141             new MockAnalysisDataModule(gmx::IAnalysisDataModule::efAllowMultipoint));
 142     EXPECT_NO_THROW_GMX(data.addModule(mod2));
 143 }
 144
 145 #if GTEST_HAS_TYPED_TEST
 146
 147 /********************************************************************
 148  * Input data for tests below.
 149  */
 150
 151 // Basic input data for gmx::AnalysisData tests.
 152 class SimpleInputData
 153 {
 154 public:
 155     static const AnalysisDataTestInput& get()
 156     {
 157 #    ifndef STATIC_ANON_NAMESPACE_BUG
 158         static SimpleInputData singleton;
 159         return singleton.data_;
 160 #    else
 161         static SimpleInputData singleton_analysisdata;
 162         return singleton_analysisdata.data_;
 163 #    endif
 164     }
 165
 166     SimpleInputData() : data_(1, false)
 167     {
 168         data_.setColumnCount(0, 3);
 169         data_.addFrameWithValues(1.0, 0.0, 1.0, 2.0);
 170         data_.addFrameWithValues(2.0, 1.0, 1.0, 1.0);
 171         data_.addFrameWithValues(3.0, 2.0, 0.0, 0.0);
 172     }
 173
 174 private:
 175     AnalysisDataTestInput data_;
 176 };
 177
 178 // Input data with multiple data sets for gmx::AnalysisData tests.
 179 class DataSetsInputData
 180 {
 181 public:
 182     static const AnalysisDataTestInput& get()
 183     {
 184 #    ifndef STATIC_ANON_NAMESPACE_BUG
 185         static DataSetsInputData singleton;
 186         return singleton.data_;
 187 #    else
 188         static DataSetsInputData singleton_analysisdata;
 189         return singleton_analysisdata.data_;
 190 #    endif
 191     }
 192
 193     DataSetsInputData() : data_(2, false)
 194     {
 195         using gmx::test::AnalysisDataTestInputFrame;
 196         data_.setColumnCount(0, 3);
 197         data_.setColumnCount(1, 2);
 198         AnalysisDataTestInputFrame& frame1 = data_.addFrame(1.0);
 199         frame1.addPointSetWithValues(0, 0, 0.0, 1.0, 2.0);
 200         frame1.addPointSetWithValues(1, 0, 2.1, 1.1);
 201         AnalysisDataTestInputFrame& frame2 = data_.addFrame(2.0);
 202         frame2.addPointSetWithValues(0, 0, 1.0, 1.0, 1.0);
 203         frame2.addPointSetWithValues(1, 0, 0.1, 2.1);
 204         AnalysisDataTestInputFrame& frame3 = data_.addFrame(3.0);
 205         frame3.addPointSetWithValues(0, 0, 2.0, 0.0, 0.0);
 206         frame3.addPointSetWithValues(1, 0, 1.1, 1.1);
 207     }
 208
 209 private:
 210     AnalysisDataTestInput data_;
 211 };
 212
 213 // Input data for multipoint gmx::AnalysisData tests.
 214 class MultipointInputData
 215 {
 216 public:
 217     static const AnalysisDataTestInput& get()
 218     {
 219 #    ifndef STATIC_ANON_NAMESPACE_BUG
 220         static MultipointInputData singleton;
 221         return singleton.data_;
 222 #    else
 223         static MultipointInputData singleton_analysisdata;
 224         return singleton_analysisdata.data_;
 225 #    endif
 226     }
 227
 228     MultipointInputData() : data_(1, true)
 229     {
 230         using gmx::test::AnalysisDataTestInputFrame;
 231         data_.setColumnCount(0, 3);
 232         AnalysisDataTestInputFrame& frame1 = data_.addFrame(1.0);
 233         frame1.addPointSetWithValues(0, 0, 0.0, 1.0, 2.0);
 234         frame1.addPointSetWithValues(0, 0, 1.1, 2.1, 1.1);
 235         frame1.addPointSetWithValues(0, 0, 2.2, 1.2, 0.2);
 236         AnalysisDataTestInputFrame& frame2 = data_.addFrame(2.0);
 237         frame2.addPointSetWithValues(0, 1, 1.0, 1.0);
 238         frame2.addPointSetWithValues(0, 0, 2.1, 1.1, 0.1);
 239         frame2.addPointSetWithValues(0, 2, 1.2);
 240         AnalysisDataTestInputFrame& frame3 = data_.addFrame(3.0);
 241         frame3.addPointSetWithValues(0, 0, 2.0, 0.0, 0.0);
 242         frame3.addPointSetWithValues(0, 0, 3.1, 2.1);
 243         frame3.addPointSetWithValues(0, 1, 2.2, 1.2);
 244     }
 245
 246 private:
 247     AnalysisDataTestInput data_;
 248 };
 249
 250 // Input data with multiple multipoint data sets for gmx::AnalysisData tests.
 251 class MultipointDataSetsInputData
 252 {
 253 public:
 254     static const AnalysisDataTestInput& get()
 255     {
 256 #    ifndef STATIC_ANON_NAMESPACE_BUG
 257         static MultipointDataSetsInputData singleton;
 258         return singleton.data_;
 259 #    else
 260         static MultipointDataSetsInputData singleton_analysisdata;
 261         return singleton_analysisdata.data_;
 262 #    endif
 263     }
 264
 265     MultipointDataSetsInputData() : data_(2, true)
 266     {
 267         using gmx::test::AnalysisDataTestInputFrame;
 268         data_.setColumnCount(0, 3);
 269         data_.setColumnCount(1, 2);
 270         AnalysisDataTestInputFrame& frame1 = data_.addFrame(1.0);
 271         frame1.addPointSetWithValues(0, 0, 0.0, 1.0, 2.0);
 272         frame1.addPointSetWithValues(0, 1, 2.1, 1.1);
 273         frame1.addPointSetWithValues(1, 0, 2.01, 1.01);
 274         frame1.addPointSetWithValues(1, 1, 0.11);
 275         AnalysisDataTestInputFrame& frame2 = data_.addFrame(2.0);
 276         frame2.addPointSetWithValues(0, 0, 1.0, 1.0, 1.0);
 277         frame2.addPointSetWithValues(0, 0, 0.1, 2.1);
 278         frame2.addPointSetWithValues(1, 1, 1.01);
 279         AnalysisDataTestInputFrame& frame3 = data_.addFrame(3.0);
 280         frame3.addPointSetWithValues(0, 0, 2.0, 0.0, 0.0);
 281         frame3.addPointSetWithValues(0, 1, 1.1);
 282     }
 283
 284 private:
 285     AnalysisDataTestInput data_;
 286 };
 287
 288 /********************************************************************
 289  * Tests for gmx::AnalysisData that require data.
 290  */
 291
 292 using gmx::test::AnalysisDataTestFixture;
 293
 294 class AnalysisDataTest : public AnalysisDataTestFixture
 295 {
 296 public:
 297     explicit AnalysisDataTest(const AnalysisDataTestInput& input) : input_(input) {}
 298
 299     void SetUp() override { ASSERT_NO_THROW_GMX(setupDataObject(input_, &data_)); }
 300
 301     void addStaticCheckerModule()
 302     {
 303         AnalysisDataTestFixture::addStaticCheckerModule(input_, &data_);
 304     }
 305     void addStaticParallelCheckerModule()
 306     {
 307         AnalysisDataTestFixture::addStaticParallelCheckerModule(input_, &data_);
 308     }
 309     void addStaticColumnCheckerModule(int firstColumn, int columnCount)
 310     {
 311         AnalysisDataTestFixture::addStaticColumnCheckerModule(input_, firstColumn, columnCount, &data_);
 312     }
 313     void addStaticStorageCheckerModule(int storageCount)
 314     {
 315         AnalysisDataTestFixture::addStaticStorageCheckerModule(input_, storageCount, &data_);
 316     }
 317     void presentAllData() { AnalysisDataTestFixture::presentAllData(input_, &data_); }
 318
 319     const AnalysisDataTestInput& input_;
 320     gmx::AnalysisData            data_;
 321 };
 322
 323 template<class InputDataType>
 324 class AnalysisDataCommonTest : public AnalysisDataTest
 325 {
 326 public:
 327     AnalysisDataCommonTest() : AnalysisDataTest(InputDataType::get()) {}
 328 };
 329
 330 //! Test fixture for tests that are only applicable to simple data.
 331 typedef AnalysisDataCommonTest<SimpleInputData> AnalysisDataSimpleTest;
 332 //! Test fixture for tests that are only applicable to multipoint data.
 333 typedef AnalysisDataCommonTest<MultipointInputData> AnalysisDataMultipointTest;
 334 //! List of input data types for tests applicable to all types of data.
 335 typedef ::testing::Types<SimpleInputData, DataSetsInputData, MultipointInputData, MultipointDataSetsInputData> AllInputDataTypes;
 336 TYPED_TEST_CASE(AnalysisDataCommonTest, AllInputDataTypes);
 337
 338 /*
 339  * Tests that data is forwarded correctly to modules using two independent
 340  * modules.
 341  */
 342 TYPED_TEST(AnalysisDataCommonTest, CallsModuleCorrectly)
 343 {
 344     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticCheckerModule());
 345     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticCheckerModule());
 346     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentAllData());
 347 }
 348
 349 /*
 350  * Tests that data is forwarded correctly to modules when there are only
 351  * parallel modules.
 352  */
 353 TYPED_TEST(AnalysisDataCommonTest, CallsParallelModuleCorrectly)
 354 {
 355     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticParallelCheckerModule());
 356     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticParallelCheckerModule());
 357     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentAllData());
 358 }
 359
 360 /*
 361  * Tests that data is forwarded correctly to modules when there are both
 362  * parallel and serial modules.
 363  */
 364 TYPED_TEST(AnalysisDataCommonTest, CallsMixedModulesCorrectly)
 365 {
 366     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticCheckerModule());
 367     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticParallelCheckerModule());
 368     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentAllData());
 369 }
 370
 371 /*
 372  * Tests that data is forwarded correctly to modules that are added using
 373  * addColumnModule().
 374  * Uses two independent modules.
 375  */
 376 TYPED_TEST(AnalysisDataCommonTest, CallsColumnModuleCorrectly)
 377 {
 378     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticColumnCheckerModule(0, 2));
 379     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticColumnCheckerModule(2, 1));
 380     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentAllData());
 381 }
 382
 383 /*
 384  * Tests that data is forwarded correctly (in frame order) to modules when the
 385  * data is added through multiple handles in non-increasing order.
 386  */
 387 TYPED_TEST(AnalysisDataCommonTest, CallsModuleCorrectlyWithOutOfOrderFrames)
 388 {
 389     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticCheckerModule());
 390     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticParallelCheckerModule());
 391     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticColumnCheckerModule(1, 2));
 392     gmx::AnalysisDataHandle          handle1;
 393     gmx::AnalysisDataHandle          handle2;
 394     gmx::AnalysisDataParallelOptions options(2);
 395     ASSERT_NO_THROW_GMX(handle1 = this->data_.startData(options));
 396     ASSERT_NO_THROW_GMX(handle2 = this->data_.startData(options));
 397     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentDataFrame(this->input_, 1, handle1));
 398     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentDataFrame(this->input_, 0, handle2));
 399     ASSERT_NO_THROW_GMX(this->data_.finishFrameSerial(0));
 400     ASSERT_NO_THROW_GMX(this->data_.finishFrameSerial(1));
 401     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentDataFrame(this->input_, 2, handle1));
 402     ASSERT_NO_THROW_GMX(this->data_.finishFrameSerial(2));
 403     ASSERT_NO_THROW_GMX(handle1.finishData());
 404     ASSERT_NO_THROW_GMX(handle2.finishData());
 405 }
 406
 407 /*
 408  * Tests that data can be accessed correctly from a module that requests
 409  * storage using AbstractAnalysisData::requestStorage() with parameter -1.
 410  */
 411 TYPED_TEST(AnalysisDataCommonTest, FullStorageWorks)
 412 {
 413     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticStorageCheckerModule(-1));
 414     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentAllData());
 415 }
 416
 417 /*
 418  * Tests that a data module can be added to an AnalysisData object after data
 419  * has been added if all data is still available in storage.
 420  */
 421 TYPED_TEST(AnalysisDataCommonTest, CanAddModuleAfterStoredData)
 422 {
 423     ASSERT_TRUE(this->data_.requestStorage(-1));
 424
 425     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentAllData());
 426     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticCheckerModule());
 427 }
 428
 429 /*
 430  * Tests that data can be accessed correctly from a module that requests
 431  * storage using AbstractAnalysisData::requestStorage() only for one frame.
 432  */
 433 TYPED_TEST(AnalysisDataCommonTest, LimitedStorageWorks)
 434 {
 435     ASSERT_NO_THROW_GMX(AnalysisDataTest::addStaticStorageCheckerModule(1));
 436     ASSERT_NO_THROW_GMX(AnalysisDataTest::presentAllData());
 437 }
 438
 439 #else
 440
 441 /* A dummy test that at least signals that something is missing if one runs the
 442  * unit test executable itself.
 443  */
 444 TEST(DISABLED_AnalysisDataCommonTest, GenericTests)
 445 {
 446     ADD_FAILURE() << "Tests for generic AnalysisData functionality require support for "
 447                   << "Google Test typed tests, which was not available when the tests "
 448                   << "were compiled.";
 449 }
 450
 451 #endif
 452
 453 } // namespace