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