src/gromacs/options/tests/filenameoptionmanager.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2014,2015,2016,2019,2021, 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 file name option implementation dependent on gmx::FileNameOptionManager.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_options
  41  */
  42 #include "gmxpre.h"
  43
  44 #include "gromacs/options/filenameoptionmanager.h"
  45
  46 #include <gtest/gtest.h>
  47
  48 #include "gromacs/fileio/filetypes.h"
  49 #include "gromacs/options/filenameoption.h"
  50 #include "gromacs/options/options.h"
  51 #include "gromacs/options/optionsassigner.h"
  52 #include "gromacs/utility/exceptions.h"
  53
  54 #include "testutils/testasserts.h"
  55 #include "testutils/testfileredirector.h"
  56
  57 namespace
  58 {
  59
  60 using gmx::FileNameOption;
  61
  62 class FileNameOptionManagerTest : public ::testing::Test
  63 {
  64 public:
  65     FileNameOptionManagerTest()
  66     {
  67         manager_.setInputRedirector(&redirector_);
  68         options_.addManager(&manager_);
  69     }
  70
  71     void addExistingFile(const char* filename) { redirector_.addExistingFile(filename); }
  72
  73     gmx::test::TestFileInputRedirector redirector_;
  74     gmx::FileNameOptionManager         manager_;
  75     gmx::Options                       options_;
  76 };
  77
  78 /********************************************************************
  79  * Actual tests
  80  */
  81
  82 TEST_F(FileNameOptionManagerTest, AddsMissingExtension)
  83 {
  84     std::string value;
  85     ASSERT_NO_THROW_GMX(options_.addOption(
  86             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Trajectory).outputFile()));
  87
  88     gmx::OptionsAssigner assigner(&options_);
  89     EXPECT_NO_THROW_GMX(assigner.start());
  90     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
  91     EXPECT_NO_THROW_GMX(assigner.appendValue("testfile"));
  92     EXPECT_NO_THROW_GMX(assigner.finishOption());
  93     EXPECT_NO_THROW_GMX(assigner.finish());
  94     EXPECT_NO_THROW_GMX(options_.finish());
  95
  96     EXPECT_EQ("testfile.xtc", value);
  97 }
  98
  99 TEST_F(FileNameOptionManagerTest, AddsMissingCustomDefaultExtension)
 100 {
 101     std::string value;
 102     ASSERT_NO_THROW_GMX(options_.addOption(
 103             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Trajectory).outputFile().defaultType(efPDB)));
 104
 105     gmx::OptionsAssigner assigner(&options_);
 106     EXPECT_NO_THROW_GMX(assigner.start());
 107     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 108     EXPECT_NO_THROW_GMX(assigner.appendValue("testfile"));
 109     EXPECT_NO_THROW_GMX(assigner.finishOption());
 110     EXPECT_NO_THROW_GMX(assigner.finish());
 111     EXPECT_NO_THROW_GMX(options_.finish());
 112
 113     EXPECT_EQ("testfile.pdb", value);
 114 }
 115
 116 TEST_F(FileNameOptionManagerTest, GivesErrorOnMissingInputFile)
 117 {
 118     std::string value;
 119     ASSERT_NO_THROW_GMX(options_.addOption(
 120             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Index).inputFile()));
 121     EXPECT_TRUE(value.empty());
 122
 123     gmx::OptionsAssigner assigner(&options_);
 124     EXPECT_NO_THROW_GMX(assigner.start());
 125     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 126     EXPECT_THROW_GMX(assigner.appendValue("missing.ndx"), gmx::InvalidInputError);
 127     EXPECT_NO_THROW_GMX(assigner.finishOption());
 128     EXPECT_NO_THROW_GMX(assigner.finish());
 129     EXPECT_NO_THROW_GMX(options_.finish());
 130
 131     EXPECT_TRUE(value.empty());
 132 }
 133
 134 TEST_F(FileNameOptionManagerTest, GivesErrorOnMissingGenericInputFile)
 135 {
 136     std::string value;
 137     ASSERT_NO_THROW_GMX(options_.addOption(
 138             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Trajectory).inputFile()));
 139     EXPECT_TRUE(value.empty());
 140
 141     gmx::OptionsAssigner assigner(&options_);
 142     EXPECT_NO_THROW_GMX(assigner.start());
 143     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 144     EXPECT_THROW_GMX(assigner.appendValue("missing.trr"), gmx::InvalidInputError);
 145     EXPECT_NO_THROW_GMX(assigner.finishOption());
 146     EXPECT_NO_THROW_GMX(assigner.finish());
 147     EXPECT_NO_THROW_GMX(options_.finish());
 148
 149     EXPECT_TRUE(value.empty());
 150 }
 151
 152 TEST_F(FileNameOptionManagerTest, GivesErrorOnMissingDefaultInputFile)
 153 {
 154     std::string value;
 155     ASSERT_NO_THROW_GMX(options_.addOption(
 156             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Index).inputFile().defaultBasename("missing")));
 157
 158     gmx::OptionsAssigner assigner(&options_);
 159     EXPECT_NO_THROW_GMX(assigner.start());
 160     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 161     EXPECT_NO_THROW_GMX(assigner.finishOption());
 162     EXPECT_NO_THROW_GMX(assigner.finish());
 163     EXPECT_THROW_GMX(options_.finish(), gmx::InvalidInputError);
 164 }
 165
 166 TEST_F(FileNameOptionManagerTest, GivesErrorOnMissingRequiredInputFile)
 167 {
 168     std::string value;
 169     ASSERT_NO_THROW_GMX(options_.addOption(FileNameOption("f")
 170                                                    .store(&value)
 171                                                    .required()
 172                                                    .filetype(gmx::OptionFileType::Index)
 173                                                    .inputFile()
 174                                                    .defaultBasename("missing")));
 175     EXPECT_EQ("missing.ndx", value);
 176
 177     gmx::OptionsAssigner assigner(&options_);
 178     EXPECT_NO_THROW_GMX(assigner.start());
 179     EXPECT_NO_THROW_GMX(assigner.finish());
 180     EXPECT_THROW_GMX(options_.finish(), gmx::InvalidInputError);
 181 }
 182
 183 TEST_F(FileNameOptionManagerTest, AcceptsMissingInputFileIfSpecified)
 184 {
 185     std::string value;
 186     ASSERT_NO_THROW_GMX(options_.addOption(
 187             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Index).inputFile().allowMissing()));
 188     EXPECT_TRUE(value.empty());
 189
 190     gmx::OptionsAssigner assigner(&options_);
 191     EXPECT_NO_THROW_GMX(assigner.start());
 192     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 193     EXPECT_NO_THROW_GMX(assigner.appendValue("missing.ndx"));
 194     EXPECT_NO_THROW_GMX(assigner.finishOption());
 195     EXPECT_NO_THROW_GMX(assigner.finish());
 196     EXPECT_NO_THROW_GMX(options_.finish());
 197
 198     EXPECT_EQ("missing.ndx", value);
 199 }
 200
 201 TEST_F(FileNameOptionManagerTest, AcceptsMissingDefaultInputFileIfSpecified)
 202 {
 203     std::string value;
 204     ASSERT_NO_THROW_GMX(options_.addOption(FileNameOption("f")
 205                                                    .store(&value)
 206                                                    .filetype(gmx::OptionFileType::Index)
 207                                                    .inputFile()
 208                                                    .defaultBasename("missing")
 209                                                    .allowMissing()));
 210
 211     gmx::OptionsAssigner assigner(&options_);
 212     EXPECT_NO_THROW_GMX(assigner.start());
 213     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 214     EXPECT_NO_THROW_GMX(assigner.finishOption());
 215     EXPECT_NO_THROW_GMX(assigner.finish());
 216     EXPECT_NO_THROW_GMX(options_.finish());
 217
 218     EXPECT_EQ("missing.ndx", value);
 219 }
 220
 221 TEST_F(FileNameOptionManagerTest, AcceptsMissingRequiredInputFileIfSpecified)
 222 {
 223     std::string value;
 224     ASSERT_NO_THROW_GMX(options_.addOption(FileNameOption("f")
 225                                                    .store(&value)
 226                                                    .required()
 227                                                    .filetype(gmx::OptionFileType::Index)
 228                                                    .inputFile()
 229                                                    .defaultBasename("missing")
 230                                                    .allowMissing()));
 231     EXPECT_EQ("missing.ndx", value);
 232
 233     gmx::OptionsAssigner assigner(&options_);
 234     EXPECT_NO_THROW_GMX(assigner.start());
 235     EXPECT_NO_THROW_GMX(assigner.finish());
 236     EXPECT_NO_THROW_GMX(options_.finish());
 237
 238     EXPECT_EQ("missing.ndx", value);
 239 }
 240
 241 TEST_F(FileNameOptionManagerTest, AddsMissingExtensionBasedOnExistingFile)
 242 {
 243     addExistingFile("testfile.trr");
 244
 245     std::string value;
 246     ASSERT_NO_THROW_GMX(options_.addOption(
 247             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Trajectory).inputFile()));
 248
 249     gmx::OptionsAssigner assigner(&options_);
 250     EXPECT_NO_THROW_GMX(assigner.start());
 251     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 252     EXPECT_NO_THROW_GMX(assigner.appendValue("testfile"));
 253     EXPECT_NO_THROW_GMX(assigner.finishOption());
 254     EXPECT_NO_THROW_GMX(assigner.finish());
 255     EXPECT_NO_THROW_GMX(options_.finish());
 256
 257     EXPECT_EQ("testfile.trr", value);
 258 }
 259
 260 TEST_F(FileNameOptionManagerTest, AddsMissingExtensionForRequiredDefaultNameBasedOnExistingFile)
 261 {
 262     addExistingFile("testfile.trr");
 263
 264     std::string value;
 265     ASSERT_NO_THROW_GMX(options_.addOption(FileNameOption("f")
 266                                                    .store(&value)
 267                                                    .required()
 268                                                    .filetype(gmx::OptionFileType::Trajectory)
 269                                                    .inputFile()
 270                                                    .defaultBasename("testfile")));
 271     EXPECT_EQ("testfile.xtc", value);
 272
 273     gmx::OptionsAssigner assigner(&options_);
 274     EXPECT_NO_THROW_GMX(assigner.start());
 275     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 276     EXPECT_NO_THROW_GMX(assigner.finishOption());
 277     EXPECT_NO_THROW_GMX(assigner.finish());
 278     EXPECT_NO_THROW_GMX(options_.finish());
 279
 280     EXPECT_EQ("testfile.trr", value);
 281 }
 282
 283 TEST_F(FileNameOptionManagerTest, AddsMissingExtensionForOptionalDefaultNameBasedOnExistingFile)
 284 {
 285     addExistingFile("testfile.trr");
 286
 287     std::string value;
 288     ASSERT_NO_THROW_GMX(options_.addOption(
 289             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Trajectory).inputFile().defaultBasename("testfile")));
 290
 291     gmx::OptionsAssigner assigner(&options_);
 292     EXPECT_NO_THROW_GMX(assigner.start());
 293     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 294     EXPECT_NO_THROW_GMX(assigner.finishOption());
 295     EXPECT_NO_THROW_GMX(assigner.finish());
 296     EXPECT_NO_THROW_GMX(options_.finish());
 297
 298     EXPECT_EQ("testfile.trr", value);
 299 }
 300
 301 TEST_F(FileNameOptionManagerTest, AddsMissingExtensionForRequiredFromDefaultNameOptionBasedOnExistingFile)
 302 {
 303     addExistingFile("testfile.trr");
 304
 305     std::string value;
 306     ASSERT_NO_THROW_GMX(options_.addOption(FileNameOption("f")
 307                                                    .store(&value)
 308                                                    .required()
 309                                                    .filetype(gmx::OptionFileType::Trajectory)
 310                                                    .inputFile()
 311                                                    .defaultBasename("foo")));
 312     ASSERT_NO_THROW_GMX(manager_.addDefaultFileNameOption(&options_, "deffnm"));
 313     EXPECT_EQ("foo.xtc", value);
 314
 315     gmx::OptionsAssigner assigner(&options_);
 316     EXPECT_NO_THROW_GMX(assigner.start());
 317     EXPECT_NO_THROW_GMX(assigner.startOption("deffnm"));
 318     EXPECT_NO_THROW_GMX(assigner.appendValue("testfile"));
 319     EXPECT_NO_THROW_GMX(assigner.finishOption());
 320     EXPECT_NO_THROW_GMX(assigner.finish());
 321     EXPECT_NO_THROW_GMX(options_.finish());
 322
 323     EXPECT_EQ("testfile.trr", value);
 324 }
 325
 326 TEST_F(FileNameOptionManagerTest, AddsMissingExtensionForOptionalFromDefaultNameOptionBasedOnExistingFile)
 327 {
 328     addExistingFile("testfile.trr");
 329
 330     std::string value;
 331     ASSERT_NO_THROW_GMX(options_.addOption(
 332             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Trajectory).inputFile().defaultBasename("foo")));
 333     ASSERT_NO_THROW_GMX(manager_.addDefaultFileNameOption(&options_, "deffnm"));
 334
 335     gmx::OptionsAssigner assigner(&options_);
 336     EXPECT_NO_THROW_GMX(assigner.start());
 337     EXPECT_NO_THROW_GMX(assigner.startOption("deffnm"));
 338     EXPECT_NO_THROW_GMX(assigner.appendValue("testfile"));
 339     EXPECT_NO_THROW_GMX(assigner.finishOption());
 340     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 341     EXPECT_NO_THROW_GMX(assigner.finishOption());
 342     EXPECT_NO_THROW_GMX(assigner.finish());
 343     EXPECT_NO_THROW_GMX(options_.finish());
 344
 345     EXPECT_EQ("testfile.trr", value);
 346 }
 347
 348 TEST_F(FileNameOptionManagerTest, DefaultNameOptionWorksWithoutInputChecking)
 349 {
 350     std::string value;
 351     ASSERT_NO_THROW_GMX(manager_.disableInputOptionChecking(true));
 352     ASSERT_NO_THROW_GMX(options_.addOption(FileNameOption("f")
 353                                                    .store(&value)
 354                                                    .required()
 355                                                    .filetype(gmx::OptionFileType::Index)
 356                                                    .inputFile()
 357                                                    .defaultBasename("default")
 358                                                    .allowMissing()));
 359     ASSERT_NO_THROW_GMX(manager_.addDefaultFileNameOption(&options_, "deffnm"));
 360     EXPECT_EQ("default.ndx", value);
 361
 362     gmx::OptionsAssigner assigner(&options_);
 363     EXPECT_NO_THROW_GMX(assigner.start());
 364     EXPECT_NO_THROW_GMX(assigner.startOption("deffnm"));
 365     EXPECT_NO_THROW_GMX(assigner.appendValue("missing"));
 366     EXPECT_NO_THROW_GMX(assigner.finishOption());
 367     EXPECT_NO_THROW_GMX(assigner.finish());
 368     EXPECT_NO_THROW_GMX(options_.finish());
 369
 370     EXPECT_EQ("missing.ndx", value);
 371 }
 372
 373 } // namespace