src/gromacs/options/tests/filenameoption.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2012,2013,2014,2015,2016 by the GROMACS development team.
   5  * Copyright (c) 2019,2020,2021, by the GROMACS development team, led by
   6  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   7  * and including many others, as listed in the AUTHORS file in the
   8  * top-level source directory and at http://www.gromacs.org.
   9  *
  10  * GROMACS is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public License
  12  * as published by the Free Software Foundation; either version 2.1
  13  * of the License, or (at your option) any later version.
  14  *
  15  * GROMACS is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with GROMACS; if not, see
  22  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  24  *
  25  * If you want to redistribute modifications to GROMACS, please
  26  * consider that scientific software is very special. Version
  27  * control is crucial - bugs must be traceable. We will be happy to
  28  * consider code for inclusion in the official distribution, but
  29  * derived work must not be called official GROMACS. Details are found
  30  * in the README & COPYING files - if they are missing, get the
  31  * official version at http://www.gromacs.org.
  32  *
  33  * To help us fund GROMACS development, we humbly ask that you cite
  34  * the research papers on the package. Check out http://www.gromacs.org.
  35  */
  36 /*! \internal \file
  37  * \brief
  38  * Tests basic file name option implementation.
  39  *
  40  * \author Teemu Murtola <teemu.murtola@gmail.com>
  41  * \ingroup module_options
  42  */
  43 #include "gmxpre.h"
  44
  45 #include "gromacs/options/filenameoption.h"
  46
  47 #include <gtest/gtest.h>
  48
  49 #include "gromacs/fileio/filetypes.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
  56 namespace
  57 {
  58
  59 using gmx::FileNameOption;
  60
  61 TEST(FileNameOptionTest, HandlesRequiredDefaultValueWithoutExtension)
  62 {
  63     gmx::Options options;
  64     std::string  value;
  65     ASSERT_NO_THROW_GMX(options.addOption(FileNameOption("f")
  66                                                   .store(&value)
  67                                                   .required()
  68                                                   .filetype(gmx::OptionFileType::GenericData)
  69                                                   .outputFile()
  70                                                   .defaultBasename("testfile")));
  71     EXPECT_EQ("testfile.dat", value);
  72
  73     gmx::OptionsAssigner assigner(&options);
  74     EXPECT_NO_THROW_GMX(assigner.start());
  75     EXPECT_NO_THROW_GMX(assigner.finish());
  76     EXPECT_NO_THROW_GMX(options.finish());
  77
  78     EXPECT_EQ("testfile.dat", value);
  79 }
  80
  81 TEST(FileNameOptionTest, HandlesRequiredOptionWithoutValue)
  82 {
  83     gmx::Options options;
  84     std::string  value;
  85     ASSERT_NO_THROW_GMX(options.addOption(FileNameOption("f")
  86                                                   .store(&value)
  87                                                   .required()
  88                                                   .filetype(gmx::OptionFileType::GenericData)
  89                                                   .outputFile()
  90                                                   .defaultBasename("testfile")));
  91     EXPECT_EQ("testfile.dat", value);
  92
  93     gmx::OptionsAssigner assigner(&options);
  94     EXPECT_NO_THROW_GMX(assigner.start());
  95     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
  96     EXPECT_NO_THROW_GMX(assigner.finishOption());
  97     EXPECT_NO_THROW_GMX(assigner.finish());
  98     EXPECT_NO_THROW_GMX(options.finish());
  99
 100     EXPECT_EQ("testfile.dat", value);
 101 }
 102
 103 TEST(FileNameOptionTest, HandlesOptionalUnsetOption)
 104 {
 105     gmx::Options options;
 106     std::string  value;
 107     ASSERT_NO_THROW_GMX(options.addOption(
 108             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Trajectory).outputFile().defaultBasename("testfile")));
 109     EXPECT_TRUE(value.empty());
 110
 111     gmx::OptionsAssigner assigner(&options);
 112     EXPECT_NO_THROW_GMX(assigner.start());
 113     EXPECT_NO_THROW_GMX(assigner.finish());
 114     EXPECT_NO_THROW_GMX(options.finish());
 115
 116     EXPECT_TRUE(value.empty());
 117 }
 118
 119 TEST(FileNameOptionTest, HandlesOptionalDefaultValueWithoutExtension)
 120 {
 121     gmx::Options options;
 122     std::string  value;
 123     ASSERT_NO_THROW_GMX(options.addOption(
 124             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Index).outputFile().defaultBasename("testfile")));
 125     EXPECT_TRUE(value.empty());
 126
 127     gmx::OptionsAssigner assigner(&options);
 128     EXPECT_NO_THROW_GMX(assigner.start());
 129     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 130     EXPECT_NO_THROW_GMX(assigner.finishOption());
 131     EXPECT_NO_THROW_GMX(assigner.finish());
 132     EXPECT_NO_THROW_GMX(options.finish());
 133
 134     EXPECT_EQ("testfile.ndx", value);
 135 }
 136
 137 TEST(FileNameOptionTest, HandlesRequiredCustomDefaultExtension)
 138 {
 139     gmx::Options options;
 140     std::string  value;
 141     ASSERT_NO_THROW_GMX(options.addOption(FileNameOption("f")
 142                                                   .store(&value)
 143                                                   .required()
 144                                                   .filetype(gmx::OptionFileType::Trajectory)
 145                                                   .outputFile()
 146                                                   .defaultBasename("testfile")
 147                                                   .defaultType(efPDB)));
 148     EXPECT_EQ("testfile.pdb", value);
 149
 150     gmx::OptionsAssigner assigner(&options);
 151     EXPECT_NO_THROW_GMX(assigner.start());
 152     EXPECT_NO_THROW_GMX(assigner.finish());
 153     EXPECT_NO_THROW_GMX(options.finish());
 154
 155     EXPECT_EQ("testfile.pdb", value);
 156 }
 157
 158 TEST(FileNameOptionTest, HandlesOptionalCustomDefaultExtension)
 159 {
 160     gmx::Options options;
 161     std::string  value;
 162     ASSERT_NO_THROW_GMX(options.addOption(FileNameOption("f")
 163                                                   .store(&value)
 164                                                   .filetype(gmx::OptionFileType::Trajectory)
 165                                                   .outputFile()
 166                                                   .defaultBasename("testfile")
 167                                                   .defaultType(efPDB)));
 168     EXPECT_TRUE(value.empty());
 169
 170     gmx::OptionsAssigner assigner(&options);
 171     EXPECT_NO_THROW_GMX(assigner.start());
 172     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 173     EXPECT_NO_THROW_GMX(assigner.finishOption());
 174     EXPECT_NO_THROW_GMX(assigner.finish());
 175     EXPECT_NO_THROW_GMX(options.finish());
 176
 177     EXPECT_EQ("testfile.pdb", value);
 178 }
 179
 180 TEST(FileNameOptionTest, GivesErrorOnUnknownFileSuffix)
 181 {
 182     gmx::Options options;
 183     std::string  value;
 184     ASSERT_NO_THROW_GMX(options.addOption(
 185             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Index).outputFile()));
 186     EXPECT_TRUE(value.empty());
 187
 188     gmx::OptionsAssigner assigner(&options);
 189     EXPECT_NO_THROW_GMX(assigner.start());
 190     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 191     EXPECT_THROW_GMX(assigner.appendValue("testfile.foo"), gmx::InvalidInputError);
 192     EXPECT_NO_THROW_GMX(assigner.finishOption());
 193     EXPECT_NO_THROW_GMX(assigner.finish());
 194     EXPECT_NO_THROW_GMX(options.finish());
 195
 196     EXPECT_TRUE(value.empty());
 197 }
 198
 199 TEST(FileNameOptionTest, GivesErrorOnInvalidFileSuffix)
 200 {
 201     gmx::Options options;
 202     std::string  value;
 203     ASSERT_NO_THROW_GMX(options.addOption(
 204             FileNameOption("f").store(&value).filetype(gmx::OptionFileType::Trajectory).outputFile()));
 205     EXPECT_TRUE(value.empty());
 206
 207     gmx::OptionsAssigner assigner(&options);
 208     EXPECT_NO_THROW_GMX(assigner.start());
 209     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 210     EXPECT_THROW_GMX(assigner.appendValue("testfile.dat"), gmx::InvalidInputError);
 211     EXPECT_NO_THROW_GMX(assigner.finishOption());
 212     EXPECT_NO_THROW_GMX(assigner.finish());
 213     EXPECT_NO_THROW_GMX(options.finish());
 214
 215     EXPECT_TRUE(value.empty());
 216 }
 217
 218 TEST(FileNameOptionTest, HandlesRequiredCsvValueWithoutExtension)
 219 {
 220     gmx::Options options;
 221     std::string  value;
 222     ASSERT_NO_THROW_GMX(options.addOption(FileNameOption("f")
 223                                                   .store(&value)
 224                                                   .required()
 225                                                   .filetype(gmx::OptionFileType::Csv)
 226                                                   .outputFile()
 227                                                   .defaultBasename("testfile")));
 228     EXPECT_EQ("testfile.csv", value);
 229
 230     gmx::OptionsAssigner assigner(&options);
 231     EXPECT_NO_THROW_GMX(assigner.start());
 232     EXPECT_NO_THROW_GMX(assigner.finish());
 233     EXPECT_NO_THROW_GMX(options.finish());
 234
 235     EXPECT_EQ("testfile.csv", value);
 236 }
 237
 238 TEST(FileNameOptionTest, HandlesRequiredCsvOptionWithoutValue)
 239 {
 240     gmx::Options options;
 241     std::string  value;
 242     ASSERT_NO_THROW_GMX(options.addOption(FileNameOption("f")
 243                                                   .store(&value)
 244                                                   .required()
 245                                                   .filetype(gmx::OptionFileType::Csv)
 246                                                   .outputFile()
 247                                                   .defaultBasename("testfile")));
 248     EXPECT_EQ("testfile.csv", value);
 249
 250     gmx::OptionsAssigner assigner(&options);
 251     EXPECT_NO_THROW_GMX(assigner.start());
 252     EXPECT_NO_THROW_GMX(assigner.startOption("f"));
 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.csv", value);
 258 }
 259
 260 } // namespace