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, 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_),
  82     flag_(false),
  83     ivalue1p_(0),
  84     ivalue12_(0)
  85 {
  86     using gmx::BooleanOption;
  87     using gmx::DoubleOption;
  88     using gmx::IntegerOption;
  89     using gmx::StringOption;
  90     options_.addOption(BooleanOption("flag").store(&flag_));
  91     options_.addOption(IntegerOption("mvi").storeVector(&ivalues_).multiValue());
  92     options_.addOption(DoubleOption("mvd").storeVector(&dvalues_).allowMultiple());
  93     options_.addOption(IntegerOption("1p").store(&ivalue1p_));
  94     options_.addOption(IntegerOption("12").store(&ivalue12_));
  95     options_.addOption(StringOption("str").store(&stringValue_));
  96 }
  97
  98 TEST_F(CommandLineParserTest, HandlesSingleValues)
  99 {
 100     const char* const cmdline[] = { "test", "-flag", "yes", "-mvi", "2", "-mvd", "2.7" };
 101     CommandLine       args(cmdline);
 102     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 103     ASSERT_NO_THROW_GMX(options_.finish());
 104     EXPECT_EQ(7, args.argc());
 105     EXPECT_STREQ("test", args.arg(0));
 106
 107     EXPECT_TRUE(flag_);
 108     ASSERT_EQ(1U, ivalues_.size());
 109     EXPECT_EQ(2, ivalues_[0]);
 110     ASSERT_EQ(1U, dvalues_.size());
 111     EXPECT_DOUBLE_EQ(2.7, dvalues_[0]);
 112 }
 113
 114 TEST_F(CommandLineParserTest, HandlesBooleanWithoutArgument)
 115 {
 116     const char* const cmdline[] = { "test", "-flag" };
 117     CommandLine       args(cmdline);
 118     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 119     ASSERT_NO_THROW_GMX(options_.finish());
 120     EXPECT_EQ(2, args.argc());
 121     EXPECT_STREQ("test", args.arg(0));
 122
 123     EXPECT_TRUE(flag_);
 124 }
 125
 126 TEST_F(CommandLineParserTest, HandlesBooleanAsNoWithoutArgument)
 127 {
 128     const char* const cmdline[] = { "test", "-noflag" };
 129     CommandLine       args(cmdline);
 130     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 131     ASSERT_NO_THROW_GMX(options_.finish());
 132     EXPECT_EQ(2, args.argc());
 133     EXPECT_STREQ("test", args.arg(0));
 134
 135     EXPECT_FALSE(flag_);
 136 }
 137
 138 TEST_F(CommandLineParserTest, ThrowsWithBooleanAsNoWithArgument)
 139 {
 140     const char* const cmdline[] = { "test", "-noflag", "no" };
 141     CommandLine       args(cmdline);
 142     EXPECT_THROW_GMX(parser_.parse(&args.argc(), args.argv()), gmx::InvalidInputError);
 143 }
 144
 145 TEST_F(CommandLineParserTest, HandlesNegativeNumbers)
 146 {
 147     const char* const cmdline[] = { "test", "-mvi", "1", "-2", "-mvd", "-2.7" };
 148     CommandLine       args(cmdline);
 149     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 150     ASSERT_NO_THROW_GMX(options_.finish());
 151     EXPECT_EQ(6, args.argc());
 152     EXPECT_STREQ("test", args.arg(0));
 153
 154     ASSERT_EQ(2U, ivalues_.size());
 155     EXPECT_EQ(1, ivalues_[0]);
 156     EXPECT_EQ(-2, ivalues_[1]);
 157     ASSERT_EQ(1U, dvalues_.size());
 158     EXPECT_DOUBLE_EQ(-2.7, dvalues_[0]);
 159 }
 160
 161 TEST_F(CommandLineParserTest, HandlesString)
 162 {
 163     const char* const cmdline[] = { "test", "-str", "text" };
 164     CommandLine       args(cmdline);
 165     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 166     ASSERT_NO_THROW_GMX(options_.finish());
 167     EXPECT_EQ(3, args.argc());
 168     EXPECT_STREQ("test", args.arg(0));
 169
 170     EXPECT_EQ("text", stringValue_);
 171 }
 172
 173 TEST_F(CommandLineParserTest, RejectsStringWithMultipleValues)
 174 {
 175     const char* const cmdline[] = { "test", "-str", "text", "excess text" };
 176     CommandLine       args(cmdline);
 177     EXPECT_THROW_GMX(parser_.parse(&args.argc(), args.argv()), gmx::InvalidInputError);
 178 }
 179
 180 TEST_F(CommandLineParserTest, HandlesDoubleDashOptionPrefix)
 181 {
 182     const char* const cmdline[] = { "test", "--mvi", "1", "-2", "--mvd", "-2.7" };
 183     CommandLine       args(cmdline);
 184     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 185     ASSERT_NO_THROW_GMX(options_.finish());
 186     EXPECT_EQ(6, args.argc());
 187     EXPECT_STREQ("test", args.arg(0));
 188
 189     ASSERT_EQ(2U, ivalues_.size());
 190     EXPECT_EQ(1, ivalues_[0]);
 191     EXPECT_EQ(-2, ivalues_[1]);
 192     ASSERT_EQ(1U, dvalues_.size());
 193     EXPECT_DOUBLE_EQ(-2.7, dvalues_[0]);
 194 }
 195
 196 TEST_F(CommandLineParserTest, HandlesOptionsStartingWithNumbers)
 197 {
 198     const char* const cmdline[] = { "test", "--12", "1", "-1p", "-12" };
 199     CommandLine       args(cmdline);
 200     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 201     ASSERT_NO_THROW_GMX(options_.finish());
 202     EXPECT_EQ(5, args.argc());
 203     EXPECT_STREQ("test", args.arg(0));
 204
 205     EXPECT_EQ(1, ivalue12_);
 206     EXPECT_EQ(-12, ivalue1p_);
 207 }
 208
 209 TEST_F(CommandLineParserTest, HandlesSkipUnknown)
 210 {
 211     const char* const cmdline[] = { "test", "-unknown1", "-flag", "-unknown2", "value",
 212                                     "-mvi", "2",         "-mvd",  "2.7",       "-unknown3" };
 213     CommandLine       args(cmdline);
 214     parser_.skipUnknown(true);
 215     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 216     ASSERT_NO_THROW_GMX(options_.finish());
 217
 218     ASSERT_EQ(5, args.argc());
 219     EXPECT_STREQ("test", args.arg(0));
 220     EXPECT_STREQ("-unknown1", args.arg(1));
 221     EXPECT_STREQ("-unknown2", args.arg(2));
 222     EXPECT_STREQ("value", args.arg(3));
 223     EXPECT_STREQ("-unknown3", args.arg(4));
 224     EXPECT_TRUE(args.arg(5) == nullptr);
 225
 226     EXPECT_TRUE(flag_);
 227     ASSERT_EQ(1U, ivalues_.size());
 228     EXPECT_EQ(2, ivalues_[0]);
 229     ASSERT_EQ(1U, dvalues_.size());
 230     EXPECT_DOUBLE_EQ(2.7, dvalues_[0]);
 231 }
 232
 233 TEST_F(CommandLineParserTest, RejectsPositionalArgumentsByDefault)
 234 {
 235     // Ensures that "gmx trjconv f" gets rejected.
 236     const char* const cmdline[] = { "test", "module", "positional" };
 237     CommandLine       args(cmdline);
 238     EXPECT_THROW_GMX(parser_.parse(&args.argc(), args.argv()), gmx::InvalidInputError);
 239 }
 240
 241 TEST_F(CommandLineParserTest, CanAllowPositionalArguments)
 242 {
 243     // Ensures that "gmx help trjconv" works
 244     const char* const cmdline[] = { "test", "module", "positional", "-flag" };
 245     CommandLine       args(cmdline);
 246     parser_.allowPositionalArguments(true);
 247     ASSERT_NO_THROW_GMX(parser_.parse(&args.argc(), args.argv()));
 248     ASSERT_NO_THROW_GMX(options_.finish());
 249     ASSERT_EQ(4, args.argc());
 250     EXPECT_STREQ("test", args.arg(0));
 251     EXPECT_STREQ("module", args.arg(1));
 252     EXPECT_STREQ("positional", args.arg(2));
 253 }
 254
 255 TEST_F(CommandLineParserTest, CannotHavePositionalArgumentsAfterOptions)
 256 {
 257     // Even for the options that can't have arbitrary numbers of
 258     // values, there's no way to check whether there's been enough
 259     // values provided, so we can't have positional arguments after
 260     // any options.
 261     const char* const cmdline[] = { "test", "module", "-1p", "2", "positional" };
 262     CommandLine       args(cmdline);
 263     parser_.allowPositionalArguments(true);
 264     EXPECT_THROW_GMX(parser_.parse(&args.argc(), args.argv()), gmx::InvalidInputError);
 265 }
 266
 267 } // namespace