src/gromacs/utility/tests/enumerationhelpers.cpp

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