src/testutils/tests/refdata.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2011,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 utilities for test reference data.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_testutils
  41  */
  42 #include "testutils/refdata.h"
  43
  44 #include <vector>
  45
  46 #include <gtest/gtest.h>
  47 #include <gtest/gtest-spi.h>
  48
  49 namespace
  50 {
  51
  52 TEST(ReferenceDataTest, HandlesSimpleData)
  53 {
  54     using gmx::test::TestReferenceData;
  55     using gmx::test::TestReferenceChecker;
  56
  57     {
  58         TestReferenceData    data(gmx::test::erefdataUpdateAll);
  59         TestReferenceChecker checker(data.rootChecker());
  60         checker.checkBoolean(true, "int");
  61         checker.checkInteger(1, "int");
  62         checker.checkDouble(0.5, "real");
  63         checker.checkString("Test", "string");
  64     }
  65     {
  66         TestReferenceData    data(gmx::test::erefdataCompare);
  67         TestReferenceChecker checker(data.rootChecker());
  68         checker.checkBoolean(true, "int");
  69         checker.checkInteger(1, "int");
  70         checker.checkDouble(0.5, "real");
  71         checker.checkString("Test", "string");
  72     }
  73 }
  74
  75 TEST(ReferenceDataTest, HandlesFloatingPointData)
  76 {
  77     using gmx::test::TestReferenceData;
  78     using gmx::test::TestReferenceChecker;
  79     const float  floatValue  = 4.0f/3.0f;
  80     const double doubleValue = 4.0/3.0;
  81
  82     {
  83         TestReferenceData    data(gmx::test::erefdataUpdateAll);
  84         TestReferenceChecker checker(data.rootChecker());
  85         checker.checkDouble(doubleValue, "double");
  86         checker.checkReal(doubleValue, "real");
  87         checker.checkFloat(floatValue, "float");
  88     }
  89     {
  90         TestReferenceData    data(gmx::test::erefdataCompare);
  91         TestReferenceChecker checker(data.rootChecker());
  92         checker.checkDouble(doubleValue, "double");
  93         checker.checkReal(floatValue, "real");
  94         checker.checkReal(doubleValue, "real");
  95         checker.checkFloat(floatValue, "float");
  96     }
  97 }
  98
  99 TEST(ReferenceDataTest, HandlesPresenceChecks)
 100 {
 101     using gmx::test::TestReferenceData;
 102     using gmx::test::TestReferenceChecker;
 103
 104     {
 105         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 106         TestReferenceChecker checker(data.rootChecker());
 107         EXPECT_TRUE(checker.checkPresent(true, "present"));
 108         checker.checkInteger(1, "present");
 109         EXPECT_FALSE(checker.checkPresent(false, "absent"));
 110     }
 111     {
 112         TestReferenceData    data(gmx::test::erefdataCompare);
 113         TestReferenceChecker checker(data.rootChecker());
 114         // Assigned to avoid warnings about potentially uninitialized value.
 115         bool                 bRet = true;
 116         EXPECT_TRUE(checker.checkPresent(true, "present"));
 117         checker.checkInteger(1, "present");
 118         EXPECT_NONFATAL_FAILURE(bRet = checker.checkPresent(false, "present"), "");
 119         EXPECT_FALSE(bRet);
 120         EXPECT_NONFATAL_FAILURE(bRet = checker.checkPresent(true, "absent"), "");
 121         EXPECT_FALSE(bRet);
 122         EXPECT_FALSE(checker.checkPresent(false, "absent"));
 123     }
 124 }
 125
 126
 127 TEST(ReferenceDataTest, HandlesStringBlockData)
 128 {
 129     using gmx::test::TestReferenceData;
 130     using gmx::test::TestReferenceChecker;
 131
 132     {
 133         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 134         TestReferenceChecker checker(data.rootChecker());
 135         checker.checkStringBlock("Line1\nLine2\n", "block");
 136         checker.checkString("Test", "string");
 137     }
 138     {
 139         TestReferenceData    data(gmx::test::erefdataCompare);
 140         TestReferenceChecker checker(data.rootChecker());
 141         checker.checkStringBlock("Line1\nLine2\n", "block");
 142         EXPECT_NONFATAL_FAILURE(checker.checkString("Line1\nLine2\n", "block"), "");
 143         EXPECT_NONFATAL_FAILURE(checker.checkStringBlock("Test", "string"), "");
 144     }
 145 }
 146
 147
 148 TEST(ReferenceDataTest, HandlesVectorData)
 149 {
 150     using gmx::test::TestReferenceData;
 151     using gmx::test::TestReferenceChecker;
 152     int    veci[3] = { -1, 3, 5 };
 153     float  vecf[3] = { -2.3f, 1.43f, 2.5f };
 154     double vecd[3] = { -2.3, 1.43, 2.5 };
 155
 156     {
 157         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 158         TestReferenceChecker checker(data.rootChecker());
 159         checker.checkVector(veci, "ivec");
 160         checker.checkVector(vecf, "fvec");
 161         checker.checkVector(vecd, "dvec");
 162     }
 163     {
 164         TestReferenceData    data(gmx::test::erefdataCompare);
 165         TestReferenceChecker checker(data.rootChecker());
 166         checker.checkVector(veci, "ivec");
 167         checker.checkVector(vecf, "fvec");
 168         checker.checkVector(vecd, "dvec");
 169     }
 170 }
 171
 172
 173 TEST(ReferenceDataTest, HandlesSequenceData)
 174 {
 175     using gmx::test::TestReferenceData;
 176     using gmx::test::TestReferenceChecker;
 177     const int seq[5] = { -1, 3, 5, 2, 4 };
 178
 179     {
 180         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 181         TestReferenceChecker checker(data.rootChecker());
 182         checker.checkSequenceArray(5, seq, "seq");
 183     }
 184     {
 185         TestReferenceData    data(gmx::test::erefdataCompare);
 186         TestReferenceChecker checker(data.rootChecker());
 187         checker.checkSequenceArray(5, seq, "seq");
 188     }
 189 }
 190
 191
 192 TEST(ReferenceDataTest, HandlesIncorrectData)
 193 {
 194     using gmx::test::TestReferenceData;
 195     using gmx::test::TestReferenceChecker;
 196     int seq[5] = { -1, 3, 5, 2, 4 };
 197
 198     {
 199         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 200         TestReferenceChecker checker(data.rootChecker());
 201         checker.checkInteger(1, "int");
 202         checker.checkDouble(0.5, "real");
 203         checker.checkString("Test", "string");
 204         checker.checkSequenceArray(5, seq, "seq");
 205     }
 206     {
 207         TestReferenceData    data(gmx::test::erefdataCompare);
 208         TestReferenceChecker checker(data.rootChecker());
 209         EXPECT_NONFATAL_FAILURE(checker.checkInteger(2, "int"), "");
 210         EXPECT_NONFATAL_FAILURE(checker.checkDouble(0.3, "real"), "");
 211         EXPECT_NONFATAL_FAILURE(checker.checkString("Test2", "string"), "");
 212         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(4, seq, "seq"), "");
 213         seq[0] = 2;
 214         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "seq"), "");
 215     }
 216 }
 217
 218
 219 TEST(ReferenceDataTest, HandlesMissingData)
 220 {
 221     using gmx::test::TestReferenceData;
 222     using gmx::test::TestReferenceChecker;
 223     const int seq[5] = { -1, 3, 5, 2, 4 };
 224
 225     {
 226         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 227         TestReferenceChecker checker(data.rootChecker());
 228         checker.checkInteger(1, "int");
 229         checker.checkSequenceArray(5, seq, "seq");
 230     }
 231     {
 232         TestReferenceData    data(gmx::test::erefdataCompare);
 233         TestReferenceChecker checker(data.rootChecker());
 234         EXPECT_NONFATAL_FAILURE(checker.checkInteger(1, "missing"), "");
 235         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "missing"), "");
 236     }
 237 }
 238
 239
 240 TEST(ReferenceDataTest, HandlesMissingReferenceDataFile)
 241 {
 242     using gmx::test::TestReferenceData;
 243     using gmx::test::TestReferenceChecker;
 244     const int seq[5] = { -1, 3, 5, 2, 4 };
 245
 246     EXPECT_NONFATAL_FAILURE({
 247                                 TestReferenceData data(gmx::test::erefdataCompare);
 248                                 TestReferenceChecker checker(data.rootChecker());
 249                                 checker.checkInteger(1, "int");
 250                                 checker.checkDouble(0.5, "real");
 251                                 checker.checkString("Test", "string");
 252                                 checker.checkSequenceArray(5, seq, "seq");
 253                             }, "");
 254 }
 255
 256
 257 TEST(ReferenceDataTest, HandlesSpecialCharactersInStrings)
 258 {
 259     using gmx::test::TestReferenceData;
 260     using gmx::test::TestReferenceChecker;
 261
 262     {
 263         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 264         TestReferenceChecker checker(data.rootChecker());
 265         checker.checkString("\"<'>\n \r &\\/;", "string");
 266         // \r is not handled correctly
 267         checker.checkStringBlock("\"<'>\n ]]> &\\/;", "stringblock");
 268     }
 269     {
 270         TestReferenceData    data(gmx::test::erefdataCompare);
 271         TestReferenceChecker checker(data.rootChecker());
 272         checker.checkString("\"<'>\n \r &\\/;", "string");
 273         checker.checkStringBlock("\"<'>\n ]]> &\\/;", "stringblock");
 274     }
 275 }
 276
 277
 278 TEST(ReferenceDataTest, HandlesSequenceItemIndices)
 279 {
 280     using gmx::test::TestReferenceData;
 281     using gmx::test::TestReferenceChecker;
 282     int seq[5] = { -1, 3, 5, 2, 4 };
 283
 284     {
 285         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 286         TestReferenceChecker checker(data.rootChecker());
 287         checker.checkSequenceArray(5, seq, "seq");
 288         checker.checkSequenceArray(5, seq, "seq2");
 289     }
 290     {
 291         TestReferenceData    data(gmx::test::erefdataCompare);
 292         TestReferenceChecker checker(data.rootChecker());
 293         seq[0] = 2;
 294         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "seq"), "seq/[0]");
 295         seq[0] = -1;
 296         seq[3] = 0;
 297         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "seq"), "seq/[3]");
 298         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "seq2"), "seq2/[3]");
 299     }
 300 }
 301
 302
 303 TEST(ReferenceDataTest, HandlesMultipleChecksAgainstSameData)
 304 {
 305     using gmx::test::TestReferenceData;
 306     using gmx::test::TestReferenceChecker;
 307
 308     {
 309         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 310         TestReferenceChecker checker(data.rootChecker());
 311         checker.checkString("Test", "string");
 312         EXPECT_NONFATAL_FAILURE(checker.checkString("Test2", "string"), "");
 313         checker.checkStringBlock("TestString", "stringblock");
 314         EXPECT_NONFATAL_FAILURE(checker.checkStringBlock("TestString2", "stringblock"), "");
 315     }
 316     {
 317         TestReferenceData    data(gmx::test::erefdataCompare);
 318         TestReferenceChecker checker(data.rootChecker());
 319         checker.checkString("Test", "string");
 320         EXPECT_NONFATAL_FAILURE(checker.checkString("Test2", "string"), "");
 321         checker.checkStringBlock("TestString", "stringblock");
 322         EXPECT_NONFATAL_FAILURE(checker.checkStringBlock("TestString2", "stringblock"), "");
 323     }
 324 }
 325
 326
 327 TEST(ReferenceDataTest, HandlesMultipleNullIds)
 328 {
 329     using gmx::test::TestReferenceData;
 330     using gmx::test::TestReferenceChecker;
 331
 332     {
 333         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 334         TestReferenceChecker checker(data.rootChecker());
 335         checker.checkString("Test", NULL);
 336         checker.checkString("Test2", NULL);
 337     }
 338     {
 339         TestReferenceData    data(gmx::test::erefdataCompare);
 340         TestReferenceChecker checker(data.rootChecker());
 341         checker.checkString("Test", NULL);
 342         checker.checkString("Test2", NULL);
 343         EXPECT_NONFATAL_FAILURE(checker.checkString("Test", NULL), "");
 344     }
 345 }
 346
 347 } // namespace