src/gromacs/options/tests/filenameoptionmanager.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 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 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/filenm.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 #include "gromacs/utility/file.h"
  54 #include "gromacs/utility/path.h"
  55
  56 #include "testutils/testasserts.h"
  57 #include "testutils/testfilemanager.h"
  58
  59 namespace
  60 {
  61
  62 using gmx::FileNameOption;
  63
  64 class FileNameOptionManagerTest : public ::testing::Test
  65 {
  66     public:
  67         FileNameOptionManagerTest()
  68             : options_(NULL, NULL)
  69         {
  70             options_.addManager(&manager_);
  71         }
  72
  73         std::string createDummyFile(const char *suffix)
  74         {
  75             std::string filename(tempFiles_.getTemporaryFilePath(suffix));
  76             gmx::File::writeFileFromString(filename, "Dummy file");
  77             return filename;
  78         }
  79
  80         gmx::FileNameOptionManager manager_;
  81         gmx::Options               options_;
  82         gmx::test::TestFileManager tempFiles_;
  83 };
  84
  85 /********************************************************************
  86  * Actual tests
  87  */
  88
  89 TEST_F(FileNameOptionManagerTest, AddsMissingExtension)
  90 {
  91     std::string value;
  92     ASSERT_NO_THROW_GMX(options_.addOption(
  93                                 FileNameOption("f").store(&value)
  94                                     .filetype(gmx::eftTrajectory).outputFile()));
  95
  96     gmx::OptionsAssigner assigner(&options_);
  97     EXPECT_NO_THROW_GMX(assigner.start());
  98     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
  99     EXPECT_NO_THROW_GMX(assigner.appendValue("testfile"));
 100     EXPECT_NO_THROW_GMX(assigner.finishOption());
 101     EXPECT_NO_THROW_GMX(assigner.finish());
 102     EXPECT_NO_THROW_GMX(options_.finish());
 103
 104     EXPECT_EQ("testfile.xtc", value);
 105 }
 106
 107 TEST_F(FileNameOptionManagerTest, AddsMissingCustomDefaultExtension)
 108 {
 109     std::string value;
 110     ASSERT_NO_THROW_GMX(options_.addOption(
 111                                 FileNameOption("f").store(&value)
 112                                     .filetype(gmx::eftTrajectory).outputFile()
 113                                     .defaultType(efPDB)));
 114
 115     gmx::OptionsAssigner assigner(&options_);
 116     EXPECT_NO_THROW_GMX(assigner.start());
 117     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 118     EXPECT_NO_THROW_GMX(assigner.appendValue("testfile"));
 119     EXPECT_NO_THROW_GMX(assigner.finishOption());
 120     EXPECT_NO_THROW_GMX(assigner.finish());
 121     EXPECT_NO_THROW_GMX(options_.finish());
 122
 123     EXPECT_EQ("testfile.pdb", value);
 124 }
 125
 126 TEST_F(FileNameOptionManagerTest, GivesErrorOnMissingInputFile)
 127 {
 128     std::string value;
 129     ASSERT_NO_THROW_GMX(options_.addOption(
 130                                 FileNameOption("f").store(&value)
 131                                     .filetype(gmx::eftIndex).inputFile()));
 132     EXPECT_TRUE(value.empty());
 133
 134     gmx::OptionsAssigner assigner(&options_);
 135     EXPECT_NO_THROW_GMX(assigner.start());
 136     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 137     EXPECT_THROW_GMX(assigner.appendValue("missing.ndx"), gmx::InvalidInputError);
 138     EXPECT_NO_THROW_GMX(assigner.finishOption());
 139     EXPECT_NO_THROW_GMX(assigner.finish());
 140     EXPECT_NO_THROW_GMX(options_.finish());
 141
 142     EXPECT_TRUE(value.empty());
 143 }
 144
 145 TEST_F(FileNameOptionManagerTest, GivesErrorOnMissingGenericInputFile)
 146 {
 147     std::string value;
 148     ASSERT_NO_THROW_GMX(options_.addOption(
 149                                 FileNameOption("f").store(&value)
 150                                     .filetype(gmx::eftTrajectory).inputFile()));
 151     EXPECT_TRUE(value.empty());
 152
 153     gmx::OptionsAssigner assigner(&options_);
 154     EXPECT_NO_THROW_GMX(assigner.start());
 155     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 156     EXPECT_THROW_GMX(assigner.appendValue("missing.trr"), gmx::InvalidInputError);
 157     EXPECT_NO_THROW_GMX(assigner.finishOption());
 158     EXPECT_NO_THROW_GMX(assigner.finish());
 159     EXPECT_NO_THROW_GMX(options_.finish());
 160
 161     EXPECT_TRUE(value.empty());
 162 }
 163
 164 TEST_F(FileNameOptionManagerTest, GivesErrorOnMissingDefaultInputFile)
 165 {
 166     std::string value;
 167     ASSERT_NO_THROW_GMX(options_.addOption(
 168                                 FileNameOption("f").store(&value)
 169                                     .filetype(gmx::eftIndex).inputFile()
 170                                     .defaultBasename("missing")));
 171
 172     gmx::OptionsAssigner assigner(&options_);
 173     EXPECT_NO_THROW_GMX(assigner.start());
 174     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 175     EXPECT_NO_THROW_GMX(assigner.finishOption());
 176     EXPECT_NO_THROW_GMX(assigner.finish());
 177     EXPECT_THROW_GMX(options_.finish(), gmx::InvalidInputError);
 178 }
 179
 180 TEST_F(FileNameOptionManagerTest, GivesErrorOnMissingRequiredInputFile)
 181 {
 182     std::string value;
 183     ASSERT_NO_THROW_GMX(options_.addOption(
 184                                 FileNameOption("f").store(&value).required()
 185                                     .filetype(gmx::eftIndex).inputFile()
 186                                     .defaultBasename("missing")));
 187     EXPECT_EQ("missing.ndx", value);
 188
 189     gmx::OptionsAssigner assigner(&options_);
 190     EXPECT_NO_THROW_GMX(assigner.start());
 191     EXPECT_NO_THROW_GMX(assigner.finish());
 192     EXPECT_THROW_GMX(options_.finish(), gmx::InvalidInputError);
 193 }
 194
 195 TEST_F(FileNameOptionManagerTest, AddsMissingExtensionBasedOnExistingFile)
 196 {
 197     std::string filename(createDummyFile(".trr"));
 198     std::string inputValue(gmx::Path::stripExtension(filename));
 199
 200     std::string value;
 201     ASSERT_NO_THROW_GMX(options_.addOption(
 202                                 FileNameOption("f").store(&value)
 203                                     .filetype(gmx::eftTrajectory).inputFile()));
 204
 205     gmx::OptionsAssigner assigner(&options_);
 206     EXPECT_NO_THROW_GMX(assigner.start());
 207     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 208     EXPECT_NO_THROW_GMX(assigner.appendValue(inputValue));
 209     EXPECT_NO_THROW_GMX(assigner.finishOption());
 210     EXPECT_NO_THROW_GMX(assigner.finish());
 211     EXPECT_NO_THROW_GMX(options_.finish());
 212
 213     EXPECT_EQ(filename, value);
 214 }
 215
 216 TEST_F(FileNameOptionManagerTest,
 217        AddsMissingExtensionForRequiredDefaultNameBasedOnExistingFile)
 218 {
 219     std::string filename(createDummyFile(".trr"));
 220     std::string inputValue(gmx::Path::stripExtension(filename));
 221
 222     std::string value;
 223     ASSERT_NO_THROW_GMX(options_.addOption(
 224                                 FileNameOption("f").store(&value).required()
 225                                     .filetype(gmx::eftTrajectory).inputFile()
 226                                     .defaultBasename(inputValue.c_str())));
 227     EXPECT_EQ(inputValue + ".xtc", value);
 228
 229     gmx::OptionsAssigner assigner(&options_);
 230     EXPECT_NO_THROW_GMX(assigner.start());
 231     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 232     EXPECT_NO_THROW_GMX(assigner.finishOption());
 233     EXPECT_NO_THROW_GMX(assigner.finish());
 234     EXPECT_NO_THROW_GMX(options_.finish());
 235
 236     EXPECT_EQ(filename, value);
 237 }
 238
 239 TEST_F(FileNameOptionManagerTest,
 240        AddsMissingExtensionForOptionalDefaultNameBasedOnExistingFile)
 241 {
 242     std::string filename(createDummyFile(".trr"));
 243     std::string inputValue(gmx::Path::stripExtension(filename));
 244
 245     std::string value;
 246     ASSERT_NO_THROW_GMX(options_.addOption(
 247                                 FileNameOption("f").store(&value)
 248                                     .filetype(gmx::eftTrajectory).inputFile()
 249                                     .defaultBasename(inputValue.c_str())));
 250
 251     gmx::OptionsAssigner assigner(&options_);
 252     EXPECT_NO_THROW_GMX(assigner.start());
 253     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 254     EXPECT_NO_THROW_GMX(assigner.finishOption());
 255     EXPECT_NO_THROW_GMX(assigner.finish());
 256     EXPECT_NO_THROW_GMX(options_.finish());
 257
 258     EXPECT_EQ(filename, value);
 259 }
 260
 261 TEST_F(FileNameOptionManagerTest,
 262        AddsMissingExtensionForRequiredFromDefaultNameOptionBasedOnExistingFile)
 263 {
 264     std::string filename(createDummyFile(".trr"));
 265     std::string inputValue(gmx::Path::stripExtension(filename));
 266
 267     std::string value;
 268     ASSERT_NO_THROW_GMX(options_.addOption(
 269                                 FileNameOption("f").store(&value).required()
 270                                     .filetype(gmx::eftTrajectory).inputFile()
 271                                     .defaultBasename("foo")));
 272     ASSERT_NO_THROW_GMX(manager_.addDefaultFileNameOption(&options_, "deffnm"));
 273     EXPECT_EQ("foo.xtc", value);
 274
 275     gmx::OptionsAssigner assigner(&options_);
 276     EXPECT_NO_THROW_GMX(assigner.start());
 277     EXPECT_NO_THROW_GMX(assigner.startOption("deffnm"));
 278     EXPECT_NO_THROW_GMX(assigner.appendValue(inputValue));
 279     EXPECT_NO_THROW_GMX(assigner.finishOption());
 280     EXPECT_NO_THROW_GMX(assigner.finish());
 281     EXPECT_NO_THROW_GMX(options_.finish());
 282
 283     EXPECT_EQ(filename, value);
 284 }
 285
 286 TEST_F(FileNameOptionManagerTest,
 287        AddsMissingExtensionForOptionalFromDefaultNameOptionBasedOnExistingFile)
 288 {
 289     std::string filename(createDummyFile(".trr"));
 290     std::string inputValue(gmx::Path::stripExtension(filename));
 291
 292     std::string value;
 293     ASSERT_NO_THROW_GMX(options_.addOption(
 294                                 FileNameOption("f").store(&value)
 295                                     .filetype(gmx::eftTrajectory).inputFile()
 296                                     .defaultBasename("foo")));
 297     ASSERT_NO_THROW_GMX(manager_.addDefaultFileNameOption(&options_, "deffnm"));
 298
 299     gmx::OptionsAssigner assigner(&options_);
 300     EXPECT_NO_THROW_GMX(assigner.start());
 301     EXPECT_NO_THROW_GMX(assigner.startOption("deffnm"));
 302     EXPECT_NO_THROW_GMX(assigner.appendValue(inputValue));
 303     EXPECT_NO_THROW_GMX(assigner.finishOption());
 304     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 305     EXPECT_NO_THROW_GMX(assigner.finishOption());
 306     EXPECT_NO_THROW_GMX(assigner.finish());
 307     EXPECT_NO_THROW_GMX(options_.finish());
 308
 309     EXPECT_EQ(filename, value);
 310 }
 311
 312 } // namespace