src/gromacs/utility/tests/stringtoenumvalueconverter.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 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 Tests for string-to-enum-value helper functor
  37  *
  38  * \author Mark Abraham <mark.j.abraham@gmail.com>
  39  * \ingroup module_utility
  40  */
  41 #include "gmxpre.h"
  42
  43 #include "gromacs/utility/stringtoenumvalueconverter.h"
  44
  45 #include <gtest/gtest.h>
  46
  47 namespace gmx
  48 {
  49
  50 namespace
  51 {
  52
  53 //! Type to use in testing
  54 enum class Foo : int
  55 {
  56     Bar,
  57     Ugh,
  58     Fooz,
  59     Weird,
  60     Empty,
  61     Count,
  62     Default = Ugh
  63 };
  64
  65 //! Declare the conventional conversion function
  66 const char* enumValueToString(Foo f)
  67 {
  68     static constexpr gmx::EnumerationArray<Foo, const char*> toString = {
  69         "Bar", "Ugh ", "Foo z", "We-i_rd", ""
  70     };
  71     return toString[f];
  72 }
  73
  74 //! Declare an atypical conversion function
  75 const char* enumValueToLetterAsString(Foo f)
  76 {
  77     static constexpr gmx::EnumerationArray<Foo, const char*> toString = { "B", "U", "F", "W", "" };
  78     return toString[f];
  79 }
  80
  81 //! Pretty-printer for GoogleTest to use
  82 ::std::ostream& operator<<(::std::ostream& os, const std::optional<Foo>& f)
  83 {
  84     if (f)
  85     {
  86         return os << enumValueToString(f.value());
  87     }
  88     else
  89     {
  90         return os << "Out-of-range Foo value";
  91     }
  92 }
  93
  94 TEST(StringToEnumValueConverterTest, ExactStringComparisonWorksWithoutStripping)
  95 {
  96     StringToEnumValueConverter<Foo, enumValueToString, StringCompareType::Exact, StripStrings::No> converter;
  97     EXPECT_EQ(converter.valueFrom("Bar"), Foo::Bar);
  98     EXPECT_FALSE(converter.valueFrom("bar"));
  99     EXPECT_EQ(converter.valueFrom("Ugh "), Foo::Ugh);
 100     EXPECT_FALSE(converter.valueFrom("ugh "));
 101     EXPECT_EQ(converter.valueFrom("Foo z"), Foo::Fooz);
 102     EXPECT_FALSE(converter.valueFrom("foo z"));
 103     EXPECT_EQ(converter.valueFrom("We-i_rd"), Foo::Weird);
 104     EXPECT_FALSE(converter.valueFrom("we-i_rd"));
 105     EXPECT_EQ(converter.valueFrom(""), Foo::Empty);
 106     EXPECT_FALSE(converter.valueFrom("count"));
 107     EXPECT_FALSE(converter.valueFrom("Unknown"));
 108     EXPECT_FALSE(converter.valueFrom("BarFoo z"));
 109     EXPECT_FALSE(converter.valueFrom("Ugh"));
 110     EXPECT_FALSE(converter.valueFrom("Default"));
 111 }
 112
 113 TEST(StringToEnumValueConverterTest, CaseInsensitiveStringComparisonWorksWithoutStripping)
 114 {
 115     StringToEnumValueConverter<Foo, enumValueToString, StringCompareType::CaseInsensitive, StripStrings::No> converter;
 116     EXPECT_EQ(converter.valueFrom("Bar"), Foo::Bar);
 117     EXPECT_EQ(converter.valueFrom("bar"), Foo::Bar);
 118     EXPECT_EQ(converter.valueFrom("Ugh "), Foo::Ugh);
 119     EXPECT_EQ(converter.valueFrom("ugh "), Foo::Ugh);
 120     EXPECT_EQ(converter.valueFrom("Foo z"), Foo::Fooz);
 121     EXPECT_EQ(converter.valueFrom("foo z"), Foo::Fooz);
 122     EXPECT_EQ(converter.valueFrom("We-i_rd"), Foo::Weird);
 123     EXPECT_EQ(converter.valueFrom("we-i_rd"), Foo::Weird);
 124     EXPECT_EQ(converter.valueFrom(""), Foo::Empty);
 125     EXPECT_FALSE(converter.valueFrom("Count"));
 126     EXPECT_FALSE(converter.valueFrom("count"));
 127     EXPECT_FALSE(converter.valueFrom("Unknown"));
 128     EXPECT_FALSE(converter.valueFrom("barfoo z"));
 129     EXPECT_FALSE(converter.valueFrom("Ugh"));
 130     EXPECT_FALSE(converter.valueFrom("Default"));
 131 }
 132
 133 TEST(StringToEnumValueConverterTest, CaseAndDashInsensitiveStringComparisonWorksWithoutStripping)
 134 {
 135     StringToEnumValueConverter<Foo, enumValueToString, StringCompareType::CaseAndDashInsensitive, StripStrings::No> converter;
 136     EXPECT_EQ(converter.valueFrom("Bar"), Foo::Bar);
 137     EXPECT_EQ(converter.valueFrom("b-ar"), Foo::Bar);
 138     EXPECT_EQ(converter.valueFrom("Ugh "), Foo::Ugh);
 139     EXPECT_EQ(converter.valueFrom("_ugh "), Foo::Ugh);
 140     EXPECT_EQ(converter.valueFrom("Foo z"), Foo::Fooz);
 141     EXPECT_EQ(converter.valueFrom("fo_o z"), Foo::Fooz);
 142     EXPECT_EQ(converter.valueFrom("We-i_rd"), Foo::Weird);
 143     EXPECT_EQ(converter.valueFrom("we-i_rd"), Foo::Weird);
 144     EXPECT_EQ(converter.valueFrom(""), Foo::Empty);
 145     EXPECT_FALSE(converter.valueFrom("Count"));
 146     EXPECT_FALSE(converter.valueFrom("count"));
 147     EXPECT_FALSE(converter.valueFrom("Unknown"));
 148     EXPECT_FALSE(converter.valueFrom("Bar-Foo z"));
 149     EXPECT_FALSE(converter.valueFrom("Ugh"));
 150     EXPECT_FALSE(converter.valueFrom("Default"));
 151 }
 152
 153 TEST(StringToEnumValueConverterTest, ExactStringComparisonWorksWithStripping)
 154 {
 155     StringToEnumValueConverter<Foo, enumValueToString, StringCompareType::Exact, StripStrings::Yes> converter;
 156     EXPECT_EQ(converter.valueFrom("Bar "), Foo::Bar);
 157     EXPECT_FALSE(converter.valueFrom("Ba r"));
 158     EXPECT_EQ(converter.valueFrom("Ugh"), Foo::Ugh);
 159     EXPECT_FALSE(converter.valueFrom("ugh"));
 160     EXPECT_EQ(converter.valueFrom("  Foo z "), Foo::Fooz);
 161     EXPECT_FALSE(converter.valueFrom(" foo z"));
 162     EXPECT_EQ(converter.valueFrom("We-i_rd  "), Foo::Weird);
 163     EXPECT_FALSE(converter.valueFrom("  we-i_rd "));
 164     EXPECT_EQ(converter.valueFrom(""), Foo::Empty);
 165     EXPECT_FALSE(converter.valueFrom(" Count"));
 166     EXPECT_FALSE(converter.valueFrom("count  "));
 167     EXPECT_FALSE(converter.valueFrom("Unknown"));
 168     EXPECT_FALSE(converter.valueFrom("Bar Foo z"));
 169     EXPECT_EQ(converter.valueFrom(" Ugh"), Foo::Ugh);
 170     EXPECT_FALSE(converter.valueFrom("Default"));
 171 }
 172
 173 TEST(StringToEnumValueConverterTest, CaseInsensitiveStringComparisonWorksWithStripping)
 174 {
 175     StringToEnumValueConverter<Foo, enumValueToString, StringCompareType::CaseInsensitive, StripStrings::Yes> converter;
 176     EXPECT_EQ(converter.valueFrom("Bar "), Foo::Bar);
 177     EXPECT_FALSE(converter.valueFrom("ba r"));
 178     EXPECT_EQ(converter.valueFrom("Ugh "), Foo::Ugh);
 179     EXPECT_EQ(converter.valueFrom("  ugh "), Foo::Ugh);
 180     EXPECT_EQ(converter.valueFrom("  Foo z "), Foo::Fooz);
 181     EXPECT_EQ(converter.valueFrom("foo z   "), Foo::Fooz);
 182     EXPECT_EQ(converter.valueFrom("We-i_rd  "), Foo::Weird);
 183     EXPECT_EQ(converter.valueFrom("  we-i_rd "), Foo::Weird);
 184     EXPECT_EQ(converter.valueFrom(""), Foo::Empty);
 185     EXPECT_FALSE(converter.valueFrom("  Count"));
 186     EXPECT_FALSE(converter.valueFrom("count "));
 187     EXPECT_FALSE(converter.valueFrom("Unknown"));
 188     EXPECT_FALSE(converter.valueFrom("  barfoo z"));
 189     EXPECT_EQ(converter.valueFrom(" Ugh"), Foo::Ugh);
 190     EXPECT_FALSE(converter.valueFrom("Default"));
 191 }
 192
 193 TEST(StringToEnumValueConverterTest, CaseAndDashInsensitiveStringComparisonWorksWithStripping)
 194 {
 195     StringToEnumValueConverter<Foo, enumValueToString, StringCompareType::CaseAndDashInsensitive, StripStrings::Yes> converter;
 196     EXPECT_EQ(converter.valueFrom("Bar "), Foo::Bar);
 197     EXPECT_FALSE(converter.valueFrom("b-a r"));
 198     EXPECT_EQ(converter.valueFrom("Ugh "), Foo::Ugh);
 199     EXPECT_EQ(converter.valueFrom(" _ugh "), Foo::Ugh);
 200     EXPECT_EQ(converter.valueFrom(" Foo z "), Foo::Fooz);
 201     EXPECT_EQ(converter.valueFrom("fo_o z  "), Foo::Fooz);
 202     EXPECT_EQ(converter.valueFrom("We-i_rd  "), Foo::Weird);
 203     EXPECT_EQ(converter.valueFrom("  we-i_rd "), Foo::Weird);
 204     EXPECT_EQ(converter.valueFrom(""), Foo::Empty);
 205     EXPECT_FALSE(converter.valueFrom("  Count"));
 206     EXPECT_FALSE(converter.valueFrom("coun-t "));
 207     EXPECT_FALSE(converter.valueFrom("Unknown"));
 208     EXPECT_FALSE(converter.valueFrom("  Bar-Foo z   "));
 209     EXPECT_EQ(converter.valueFrom("Ugh  "), Foo::Ugh);
 210     EXPECT_FALSE(converter.valueFrom("Default"));
 211 }
 212
 213 TEST(StringToEnumValueConverterTest, CustomConverterWorks)
 214 {
 215     StringToEnumValueConverter<Foo, enumValueToLetterAsString> converter;
 216     EXPECT_EQ(converter.valueFrom("B"), Foo::Bar);
 217     EXPECT_FALSE(converter.valueFrom("b"));
 218     EXPECT_EQ(converter.valueFrom("U"), Foo::Ugh);
 219     EXPECT_FALSE(converter.valueFrom("u"));
 220     EXPECT_EQ(converter.valueFrom("F"), Foo::Fooz);
 221     EXPECT_FALSE(converter.valueFrom("f"));
 222     EXPECT_EQ(converter.valueFrom(""), Foo::Empty);
 223     EXPECT_FALSE(converter.valueFrom("C"));
 224     EXPECT_FALSE(converter.valueFrom("c"));
 225     EXPECT_FALSE(converter.valueFrom("X"));
 226     EXPECT_FALSE(converter.valueFrom("Default"));
 227 }
 228
 229 } // namespace
 230 } // namespace gmx