src/gromacs/utility/tests/enumerationhelpers.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2019,2020,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 enumeration helpers
  37  *
  38  * \author Mark Abraham <mark.j.abraham@gmail.com>
  39  * \ingroup module_utility
  40  */
  41 #include "gmxpre.h"
  42
  43 #include "gromacs/utility/enumerationhelpers.h"
  44
  45 #include <iostream>
  46
  47 #include <gtest/gtest.h>
  48
  49 #include "gromacs/utility/arrayref.h"
  50
  51 #include "testutils/testasserts.h"
  52
  53 namespace gmx
  54 {
  55 namespace
  56 {
  57
  58 //! Type to use in testing
  59 enum class Foo
  60 {
  61     Bar,
  62     Baz,
  63     Fooz,
  64     Count
  65 };
  66
  67 TEST(EnumerationHelpersTest, EnumerationWrapperWorks)
  68 {
  69     EnumerationWrapper<Foo> iter;
  70
  71     // Range-based for works
  72     int i = 0;
  73     for (Foo c : iter)
  74     {
  75         EXPECT_EQ(static_cast<int>(c), i++);
  76     }
  77
  78     // Normal iterators work
  79     i = 0;
  80     for (auto c = iter.begin(); c != iter.end(); ++c)
  81     {
  82         EXPECT_EQ(static_cast<int>(*c), i++);
  83     }
  84
  85     auto a = std::begin(iter);
  86     auto b = std::begin(iter);
  87
  88     ASSERT_EQ(a, b);
  89     ASSERT_EQ(*(a++), Foo::Bar);
  90     ASSERT_EQ(*(++b), Foo::Baz);
  91 }
  92
  93 TEST(EnumerationHelpersTest, EnumerationArrayWorks)
  94 {
  95     using FooArray = EnumerationArray<Foo, std::string>;
  96     const FooArray fooStrings{ { "Bar", "Baz", "Fooz" } };
  97
  98     // Keys give you the constants associated with each array index.
  99     int i = 0;
 100     for (auto k : FooArray::keys())
 101     {
 102         EXPECT_EQ(static_cast<int>(k), i++);
 103     }
 104
 105     // Keys give you the constants associated with each array index.
 106     i = 0;
 107     for (auto k : keysOf(fooStrings))
 108     {
 109         EXPECT_EQ(static_cast<int>(k), i++);
 110     }
 111
 112     // Using iterators and operator[] gives the array values.
 113     i = 0;
 114     for (const auto& s : fooStrings)
 115     {
 116         EXPECT_EQ(s, fooStrings[i++]);
 117     }
 118
 119     // Using reverse iterators gives the array values.
 120     i = 2;
 121     for (auto s = fooStrings.rbegin(); s != fooStrings.rend(); ++s)
 122     {
 123         EXPECT_EQ((*s), fooStrings[i--]);
 124     }
 125
 126     // Incrementing iterators works
 127     const auto* x = std::begin(fooStrings);
 128     EXPECT_EQ(*x, "Bar");
 129     ++x;
 130     EXPECT_EQ(*x, "Baz");
 131     ++x;
 132     EXPECT_EQ(*x, "Fooz");
 133
 134     // Operator[] can be used with enumeration values.
 135     EXPECT_EQ(fooStrings[Foo::Bar], "Bar");
 136     EXPECT_EQ(fooStrings[Foo::Baz], "Baz");
 137     EXPECT_EQ(fooStrings[Foo::Fooz], "Fooz");
 138 }
 139
 140 TEST(EnumerationHelpersTest, EnumerationArrayCountIsSafe)
 141 {
 142     using FooArray = EnumerationArray<Foo, std::string>;
 143     const FooArray fooStrings{ { "Bar", "Baz", "Fooz" } };
 144
 145     // Ensures that the assertions in EnumerationArray::operator[]
 146     // would fire if an out-range value (including Count) was used.
 147     EXPECT_LE(fooStrings.size(), size_t(Foo::Count));
 148 #ifndef NDEBUG
 149     // Tests (where possible) that those assertions do fire in a build
 150     // with debug behavior.
 151     GMX_EXPECT_DEATH_IF_SUPPORTED(fooStrings[Foo::Count], "index out of range");
 152 #endif
 153 }
 154
 155 //! Helper function
 156 void func(ArrayRef<const int> a)
 157 {
 158     EXPECT_EQ(3, a[1]);
 159 }
 160
 161 TEST(EnumerationHelpersTest, ArrayRefOfEnumerationArrayWorks)
 162 {
 163     using FooArray = EnumerationArray<Foo, int>;
 164
 165     FooArray counts = { { 2, 3, 1 } };
 166
 167     // Test that explicit conversion works
 168     ArrayRef<const int> arrayRef(counts);
 169     EXPECT_EQ(3, arrayRef[1]);
 170
 171     // Test that implicit conversion works
 172     func(counts);
 173
 174     // Note that ArrayRef<int> arrayRef(counts) does not compile, as
 175     // expected, but we can't test for that.
 176 }
 177
 178 } // namespace
 179 } // namespace gmx