src/testutils/tests/refdata.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2011,2012,2013, 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 <vector>
  43
  44 #include <gtest/gtest.h>
  45 #include <gtest/gtest-spi.h>
  46
  47 #include "testutils/refdata.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, HandlesPresenceChecks)
  76 {
  77     using gmx::test::TestReferenceData;
  78     using gmx::test::TestReferenceChecker;
  79
  80     {
  81         TestReferenceData    data(gmx::test::erefdataUpdateAll);
  82         TestReferenceChecker checker(data.rootChecker());
  83         EXPECT_TRUE(checker.checkPresent(true, "present"));
  84         checker.checkInteger(1, "present");
  85         EXPECT_FALSE(checker.checkPresent(false, "absent"));
  86     }
  87     {
  88         TestReferenceData    data(gmx::test::erefdataCompare);
  89         TestReferenceChecker checker(data.rootChecker());
  90         // Assigned to avoid warnings about potentially uninitialized value.
  91         bool                 bRet = true;
  92         EXPECT_TRUE(checker.checkPresent(true, "present"));
  93         checker.checkInteger(1, "present");
  94         EXPECT_NONFATAL_FAILURE(bRet = checker.checkPresent(false, "present"), "");
  95         EXPECT_FALSE(bRet);
  96         EXPECT_NONFATAL_FAILURE(bRet = checker.checkPresent(true, "absent"), "");
  97         EXPECT_FALSE(bRet);
  98         EXPECT_FALSE(checker.checkPresent(false, "absent"));
  99     }
 100 }
 101
 102
 103 TEST(ReferenceDataTest, HandlesStringBlockData)
 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         checker.checkStringBlock("Line1\nLine2\n", "block");
 112         checker.checkString("Test", "string");
 113     }
 114     {
 115         TestReferenceData    data(gmx::test::erefdataCompare);
 116         TestReferenceChecker checker(data.rootChecker());
 117         checker.checkStringBlock("Line1\nLine2\n", "block");
 118         EXPECT_NONFATAL_FAILURE(checker.checkString("Line1\nLine2\n", "block"), "");
 119         EXPECT_NONFATAL_FAILURE(checker.checkStringBlock("Test", "string"), "");
 120     }
 121 }
 122
 123
 124 TEST(ReferenceDataTest, HandlesVectorData)
 125 {
 126     using gmx::test::TestReferenceData;
 127     using gmx::test::TestReferenceChecker;
 128     int    veci[3] = { -1, 3, 5 };
 129     float  vecf[3] = { -2.3f, 1.43f, 2.5f };
 130     double vecd[3] = { -2.3, 1.43, 2.5 };
 131
 132     {
 133         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 134         TestReferenceChecker checker(data.rootChecker());
 135         checker.checkVector(veci, "ivec");
 136         checker.checkVector(vecf, "fvec");
 137         checker.checkVector(vecd, "dvec");
 138     }
 139     {
 140         TestReferenceData    data(gmx::test::erefdataCompare);
 141         TestReferenceChecker checker(data.rootChecker());
 142         checker.checkVector(veci, "ivec");
 143         checker.checkVector(vecf, "fvec");
 144         checker.checkVector(vecd, "dvec");
 145     }
 146 }
 147
 148
 149 TEST(ReferenceDataTest, HandlesSequenceData)
 150 {
 151     using gmx::test::TestReferenceData;
 152     using gmx::test::TestReferenceChecker;
 153     const int seq[5] = { -1, 3, 5, 2, 4 };
 154
 155     {
 156         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 157         TestReferenceChecker checker(data.rootChecker());
 158         checker.checkSequenceArray(5, seq, "seq");
 159     }
 160     {
 161         TestReferenceData    data(gmx::test::erefdataCompare);
 162         TestReferenceChecker checker(data.rootChecker());
 163         checker.checkSequenceArray(5, seq, "seq");
 164     }
 165 }
 166
 167
 168 TEST(ReferenceDataTest, HandlesIncorrectData)
 169 {
 170     using gmx::test::TestReferenceData;
 171     using gmx::test::TestReferenceChecker;
 172     int seq[5] = { -1, 3, 5, 2, 4 };
 173
 174     {
 175         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 176         TestReferenceChecker checker(data.rootChecker());
 177         checker.checkInteger(1, "int");
 178         checker.checkDouble(0.5, "real");
 179         checker.checkString("Test", "string");
 180         checker.checkSequenceArray(5, seq, "seq");
 181     }
 182     {
 183         TestReferenceData    data(gmx::test::erefdataCompare);
 184         TestReferenceChecker checker(data.rootChecker());
 185         EXPECT_NONFATAL_FAILURE(checker.checkInteger(2, "int"), "");
 186         EXPECT_NONFATAL_FAILURE(checker.checkDouble(0.3, "real"), "");
 187         EXPECT_NONFATAL_FAILURE(checker.checkString("Test2", "string"), "");
 188         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(4, seq, "seq"), "");
 189         seq[0] = 2;
 190         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "seq"), "");
 191     }
 192 }
 193
 194
 195 TEST(ReferenceDataTest, HandlesMissingData)
 196 {
 197     using gmx::test::TestReferenceData;
 198     using gmx::test::TestReferenceChecker;
 199     const int seq[5] = { -1, 3, 5, 2, 4 };
 200
 201     {
 202         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 203         TestReferenceChecker checker(data.rootChecker());
 204         checker.checkInteger(1, "int");
 205         checker.checkSequenceArray(5, seq, "seq");
 206     }
 207     {
 208         TestReferenceData    data(gmx::test::erefdataCompare);
 209         TestReferenceChecker checker(data.rootChecker());
 210         EXPECT_NONFATAL_FAILURE(checker.checkInteger(1, "missing"), "");
 211         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "missing"), "");
 212     }
 213 }
 214
 215
 216 TEST(ReferenceDataTest, HandlesMissingReferenceDataFile)
 217 {
 218     using gmx::test::TestReferenceData;
 219     using gmx::test::TestReferenceChecker;
 220     const int seq[5] = { -1, 3, 5, 2, 4 };
 221
 222     EXPECT_NONFATAL_FAILURE({
 223                                 TestReferenceData data(gmx::test::erefdataCompare);
 224                                 TestReferenceChecker checker(data.rootChecker());
 225                                 checker.checkInteger(1, "int");
 226                                 checker.checkDouble(0.5, "real");
 227                                 checker.checkString("Test", "string");
 228                                 checker.checkSequenceArray(5, seq, "seq");
 229                             }, "");
 230 }
 231
 232
 233 TEST(ReferenceDataTest, HandlesSpecialCharactersInStrings)
 234 {
 235     using gmx::test::TestReferenceData;
 236     using gmx::test::TestReferenceChecker;
 237
 238     {
 239         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 240         TestReferenceChecker checker(data.rootChecker());
 241         checker.checkString("\"<'>\n \r &\\/;", "string");
 242         // \r is not handled correctly
 243         checker.checkStringBlock("\"<'>\n ]]> &\\/;", "stringblock");
 244     }
 245     {
 246         TestReferenceData    data(gmx::test::erefdataCompare);
 247         TestReferenceChecker checker(data.rootChecker());
 248         checker.checkString("\"<'>\n \r &\\/;", "string");
 249         checker.checkStringBlock("\"<'>\n ]]> &\\/;", "stringblock");
 250     }
 251 }
 252
 253
 254 TEST(ReferenceDataTest, HandlesSequenceItemIndices)
 255 {
 256     using gmx::test::TestReferenceData;
 257     using gmx::test::TestReferenceChecker;
 258     int seq[5] = { -1, 3, 5, 2, 4 };
 259
 260     {
 261         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 262         TestReferenceChecker checker(data.rootChecker());
 263         checker.checkSequenceArray(5, seq, "seq");
 264         checker.checkSequenceArray(5, seq, "seq2");
 265     }
 266     {
 267         TestReferenceData    data(gmx::test::erefdataCompare);
 268         TestReferenceChecker checker(data.rootChecker());
 269         seq[0] = 2;
 270         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "seq"), "seq/[0]");
 271         seq[0] = -1;
 272         seq[3] = 0;
 273         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "seq"), "seq/[3]");
 274         EXPECT_NONFATAL_FAILURE(checker.checkSequenceArray(5, seq, "seq2"), "seq2/[3]");
 275     }
 276 }
 277
 278
 279 TEST(ReferenceDataTest, HandlesMultipleChecksAgainstSameData)
 280 {
 281     using gmx::test::TestReferenceData;
 282     using gmx::test::TestReferenceChecker;
 283
 284     {
 285         TestReferenceData    data(gmx::test::erefdataUpdateAll);
 286         TestReferenceChecker checker(data.rootChecker());
 287         checker.checkString("Test", "string");
 288         EXPECT_NONFATAL_FAILURE(checker.checkString("Test2", "string"), "");
 289         checker.checkStringBlock("TestString", "stringblock");
 290         EXPECT_NONFATAL_FAILURE(checker.checkStringBlock("TestString2", "stringblock"), "");
 291     }
 292     {
 293         TestReferenceData    data(gmx::test::erefdataCompare);
 294         TestReferenceChecker checker(data.rootChecker());
 295         checker.checkString("Test", "string");
 296         EXPECT_NONFATAL_FAILURE(checker.checkString("Test2", "string"), "");
 297         checker.checkStringBlock("TestString", "stringblock");
 298         EXPECT_NONFATAL_FAILURE(checker.checkStringBlock("TestString2", "stringblock"), "");
 299     }
 300 }
 301
 302
 303 TEST(ReferenceDataTest, HandlesMultipleNullIds)
 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", NULL);
 312         checker.checkString("Test2", NULL);
 313     }
 314     {
 315         TestReferenceData    data(gmx::test::erefdataCompare);
 316         TestReferenceChecker checker(data.rootChecker());
 317         checker.checkString("Test", NULL);
 318         checker.checkString("Test2", NULL);
 319         EXPECT_NONFATAL_FAILURE(checker.checkString("Test", NULL), "");
 320     }
 321 }
 322
 323 } // namespace