src/gromacs/commandline/tests/cmdlineparser.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2010-2018, The GROMACS development team.
   5  * Copyright (c) 2019,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 gmx::CommandLineParser.
  39  *
  40  * These tests exercise a large fraction of the code, so they may
  41  * catch errors in other parts than just in command-line parsing.
  42  *
  43  * \author Teemu Murtola <teemu.murtola@gmail.com>
  44  * \ingroup module_commandline
  45  */
  46 #include "gmxpre.h"
  47
  48 #include "gromacs/commandline/cmdlineparser.h"
  49
  50 #include <vector>
  51
  52 #include <gtest/gtest.h>
  53
  54 #include "gromacs/options/basicoptions.h"
  55 #include "gromacs/options/options.h"
  56
  57 #include "testutils/cmdlinetest.h"
  58 #include "testutils/testasserts.h"
  59
  60 namespace
  61 {
  62
  63 using gmx::test::CommandLine;
  64
  65 class CommandLineParserTest : public ::testing::Test
  66 {
  67 public:
  68     CommandLineParserTest();
  69
  70     gmx::Options           options_;
  71     gmx::CommandLineParser parser_;
  72     bool                   flag_;
  73     std::vector<int>       ivalues_;
  74     std::vector<double>    dvalues_;
  75     int                    ivalue1p_;
  76     int                    ivalue12_;
  77     std::string            stringValue_;
  78 };
  79
  80 CommandLineParserTest::CommandLineParserTest() :
  81     parser_(&options_), flag_(false), ivalue1p_(0), ivalue12_(0)
  82 {
  83     using gmx::BooleanOption;
  84     using gmx::DoubleOption;
  85     using gmx::IntegerOption;
  86     using gmx::StringOption;
  87     options_.addOption(BooleanOption("flag").store(&flag_));
  88     options_.addOption(IntegerOption("mvi").storeVector(&ivalues_).multiValue());
  89     options_.addOption(DoubleOption("mvd").storeVector(&dvalues_).allowMultiple());
  90     options_.addOption(IntegerOption("1p").store(&ivalue1p_));
  91     options_.addOption(IntegerOption("12").store(&ivalue12_));
  92     options_.addOption(StringOption("str").store(&stringValue_));
  93 }
  94
  95 TEST_F(CommandLineParserTest, HandlesSingleValues)
  96 {
  97     const char* const cmdline[] = { "test", "-flag", "yes", "-mvi", "2", "-mvd", "2.7" };
  98     CommandLine       args(cmdline);
  99     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 100     ASSERT_NO_THROW_GMX(options_.finish());
 101     EXPECT_EQ(7, args.argc());
 102     EXPECT_STREQ("test", args.arg(0));
 103
 104     EXPECT_TRUE(flag_);
 105     ASSERT_EQ(1U, ivalues_.size());
 106     EXPECT_EQ(2, ivalues_[0]);
 107     ASSERT_EQ(1U, dvalues_.size());
 108     EXPECT_DOUBLE_EQ(2.7, dvalues_[0]);
 109 }
 110
 111 TEST_F(CommandLineParserTest, HandlesBooleanWithoutArgument)
 112 {
 113     const char* const cmdline[] = { "test", "-flag" };
 114     CommandLine       args(cmdline);
 115     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 116     ASSERT_NO_THROW_GMX(options_.finish());
 117     EXPECT_EQ(2, args.argc());
 118     EXPECT_STREQ("test", args.arg(0));
 119
 120     EXPECT_TRUE(flag_);
 121 }
 122
 123 TEST_F(CommandLineParserTest, HandlesBooleanAsNoWithoutArgument)
 124 {
 125     const char* const cmdline[] = { "test", "-noflag" };
 126     CommandLine       args(cmdline);
 127     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 128     ASSERT_NO_THROW_GMX(options_.finish());
 129     EXPECT_EQ(2, args.argc());
 130     EXPECT_STREQ("test", args.arg(0));
 131
 132     EXPECT_FALSE(flag_);
 133 }
 134
 135 TEST_F(CommandLineParserTest, ThrowsWithBooleanAsNoWithArgument)
 136 {
 137     const char* const cmdline[] = { "test", "-noflag", "no" };
 138     CommandLine       args(cmdline);
 139     EXPECT_THROW_GMX(parser_.parse(&args.argc(), args.argv()), gmx::InvalidInputError);
 140 }
 141
 142 TEST_F(CommandLineParserTest, HandlesNegativeNumbers)
 143 {
 144     const char* const cmdline[] = { "test", "-mvi", "1", "-2", "-mvd", "-2.7" };
 145     CommandLine       args(cmdline);
 146     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 147     ASSERT_NO_THROW_GMX(options_.finish());
 148     EXPECT_EQ(6, args.argc());
 149     EXPECT_STREQ("test", args.arg(0));
 150
 151     ASSERT_EQ(2U, ivalues_.size());
 152     EXPECT_EQ(1, ivalues_[0]);
 153     EXPECT_EQ(-2, ivalues_[1]);
 154     ASSERT_EQ(1U, dvalues_.size());
 155     EXPECT_DOUBLE_EQ(-2.7, dvalues_[0]);
 156 }
 157
 158 TEST_F(CommandLineParserTest, HandlesString)
 159 {
 160     const char* const cmdline[] = { "test", "-str", "text" };
 161     CommandLine       args(cmdline);
 162     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 163     ASSERT_NO_THROW_GMX(options_.finish());
 164     EXPECT_EQ(3, args.argc());
 165     EXPECT_STREQ("test", args.arg(0));
 166
 167     EXPECT_EQ("text", stringValue_);
 168 }
 169
 170 TEST_F(CommandLineParserTest, RejectsStringWithMultipleValues)
 171 {
 172     const char* const cmdline[] = { "test", "-str", "text", "excess text" };
 173     CommandLine       args(cmdline);
 174     EXPECT_THROW_GMX(parser_.parse(&args.argc(), args.argv()), gmx::InvalidInputError);
 175 }
 176
 177 TEST_F(CommandLineParserTest, HandlesDoubleDashOptionPrefix)
 178 {
 179     const char* const cmdline[] = { "test", "--mvi", "1", "-2", "--mvd", "-2.7" };
 180     CommandLine       args(cmdline);
 181     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 182     ASSERT_NO_THROW_GMX(options_.finish());
 183     EXPECT_EQ(6, args.argc());
 184     EXPECT_STREQ("test", args.arg(0));
 185
 186     ASSERT_EQ(2U, ivalues_.size());
 187     EXPECT_EQ(1, ivalues_[0]);
 188     EXPECT_EQ(-2, ivalues_[1]);
 189     ASSERT_EQ(1U, dvalues_.size());
 190     EXPECT_DOUBLE_EQ(-2.7, dvalues_[0]);
 191 }
 192
 193 TEST_F(CommandLineParserTest, HandlesOptionsStartingWithNumbers)
 194 {
 195     const char* const cmdline[] = { "test", "--12", "1", "-1p", "-12" };
 196     CommandLine       args(cmdline);
 197     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 198     ASSERT_NO_THROW_GMX(options_.finish());
 199     EXPECT_EQ(5, args.argc());
 200     EXPECT_STREQ("test", args.arg(0));
 201
 202     EXPECT_EQ(1, ivalue12_);
 203     EXPECT_EQ(-12, ivalue1p_);
 204 }
 205
 206 TEST_F(CommandLineParserTest, HandlesSkipUnknown)
 207 {
 208     const char* const cmdline[] = { "test", "-unknown1", "-flag", "-unknown2", "value",
 209                                     "-mvi", "2",         "-mvd",  "2.7",       "-unknown3" };
 210     CommandLine       args(cmdline);
 211     parser_.skipUnknown(true);
 212     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 213     ASSERT_NO_THROW_GMX(options_.finish());
 214
 215     ASSERT_EQ(5, args.argc());
 216     EXPECT_STREQ("test", args.arg(0));
 217     EXPECT_STREQ("-unknown1", args.arg(1));
 218     EXPECT_STREQ("-unknown2", args.arg(2));
 219     EXPECT_STREQ("value", args.arg(3));
 220     EXPECT_STREQ("-unknown3", args.arg(4));
 221     EXPECT_TRUE(args.arg(5) == nullptr);
 222
 223     EXPECT_TRUE(flag_);
 224     ASSERT_EQ(1U, ivalues_.size());
 225     EXPECT_EQ(2, ivalues_[0]);
 226     ASSERT_EQ(1U, dvalues_.size());
 227     EXPECT_DOUBLE_EQ(2.7, dvalues_[0]);
 228 }
 229
 230 TEST_F(CommandLineParserTest, RejectsPositionalArgumentsByDefault)
 231 {
 232     // Ensures that "gmx trjconv f" gets rejected.
 233     const char* const cmdline[] = { "test", "module", "positional" };
 234     CommandLine       args(cmdline);
 235     EXPECT_THROW_GMX(parser_.parse(&args.argc(), args.argv()), gmx::InvalidInputError);
 236 }
 237
 238 TEST_F(CommandLineParserTest, CanAllowPositionalArguments)
 239 {
 240     // Ensures that "gmx help trjconv" works
 241     const char* const cmdline[] = { "test", "module", "positional", "-flag" };
 242     CommandLine       args(cmdline);
 243     parser_.allowPositionalArguments(true);
 244     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 245     ASSERT_NO_THROW_GMX(options_.finish());
 246     ASSERT_EQ(4, args.argc());
 247     EXPECT_STREQ("test", args.arg(0));
 248     EXPECT_STREQ("module", args.arg(1));
 249     EXPECT_STREQ("positional", args.arg(2));
 250 }
 251
 252 TEST_F(CommandLineParserTest, CannotHavePositionalArgumentsAfterOptions)
 253 {
 254     // Even for the options that can't have arbitrary numbers of
 255     // values, there's no way to check whether there's been enough
 256     // values provided, so we can't have positional arguments after
 257     // any options.
 258     const char* const cmdline[] = { "test", "module", "-1p", "2", "positional" };
 259     CommandLine       args(cmdline);
 260     parser_.allowPositionalArguments(true);
 261     EXPECT_THROW_GMX(parser_.parse(&args.argc(), args.argv()), gmx::InvalidInputError);
 262 }
 263
 264 } // namespace